Come ottenere il numero di build / versione della tua applicazione Android?

Devo capire come ottenere o creare un numero di build per la mia applicazione Android. Ho bisogno del numero di build da visualizzare nell'interfaccia utente.

Devo fare qualcosa con AndroidManifest.xml?

Uso:

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

E puoi ottenere il codice della versione usando questo

int verCode = pInfo.versionCode;

Se si utilizza il plug-in Gradle / Android Studio, a partire dalla versione 0.7.0 , il codice della versione e il nome della versione sono disponibili staticamente in BuildConfig. Assicurati di importare il pacchetto dell'app e non un altro BuildConfig:

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

Nessun oggetto di contesto necessario!

Assicurati inoltre di specificarli nel tuo build.gradlefile anziché in AndroidManifest.xml.

defaultConfig {
    versionCode 1
    versionName "1.0"
}

Versione leggermente più corta se si desidera solo il nome della versione.

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

Sono necessarie due parti: android: versionCode android: versionName

versionCode è un numero e ogni versione dell'app che invii al mercato deve avere un numero maggiore dell'ultima.

VersionName è una stringa e può essere qualsiasi cosa tu voglia che sia. Qui è dove definisci la tua app come "1.0" o "2.5" o "2 Alpha EXTREME!" o qualunque altra cosa.

Esempio:

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)

Giava:

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

Utilizzo di Gradle e BuildConfig

Ottenere il VERSION_NAME da BuildConfig

BuildConfig.VERSION_NAME

Sì, è così facile ora.

Restituisce una stringa vuota per VERSION_NAME?

Se stai ricevendo una stringa vuota per BuildConfig.VERSION_NAMEallora continua a leggere.

Continuavo a ricevere una stringa vuota BuildConfig.VERSION_NAMEperché non avevo impostato il versionNamefile di build Grade (sono passato da ANT a Gradle). Quindi, ecco le istruzioni per assicurarti di impostare 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: questo è del magistrale Jake Wharton .

Rimozione versionNamee versionCodedaAndroidManifest.xml

E poiché ora hai impostato il versionNamee versionCodenel build.gradlefile, puoi anche rimuoverli dal tuo AndroidManifest.xmlfile, se sono lì.

Ecco una soluzione pulita , basata sulla soluzione di scottyab (a cura di Xavi). Mostra come ottenere prima il contesto, se non è fornito dal metodo. Inoltre utilizza più linee invece di chiamare più metodi per linea. Ciò semplifica il debug dell'applicazione.

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

Ora che hai ricevuto il nome della versione nella stringa myVersionName, puoi impostarlo su un oggetto TextView o come preferisci.

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

Per ottenere la versione dell'app o il codice build utilizzato per identificare l'apk tramite il suo codice versione. Il codice della versione viene utilizzato per rilevare la configurazione di build effettiva al momento dell'aggiornamento, della pubblicazione, ecc.

int versionCode = BuildConfig.VERSION_CODE;

Il nome della versione viene utilizzato per mostrare agli utenti o agli sviluppatori della sequenza di sviluppo. Puoi aggiungere qualsiasi tipo di nome della versione che desideri

String versionName = BuildConfig.VERSION_NAME;

Usa la classe BuildConfig

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

build.gradle (app)

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

Se stai usando PhoneGap, quindi crea un plug-in PhoneGap personalizzato:

Crea una nuova classe nel pacchetto della tua app:

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

Nel plugins.xml, aggiungi la seguente riga:

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

Nel tuo evento deviceready , aggiungi il seguente codice:

var PackageManagerPlugin = function() {

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

Quindi, puoi ottenere l'attributo versionName facendo:

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

Derivato da qui e qui .

Kotlin a una fodera

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

Assicurati di importare BuildConfignella tua classe

Per gli utenti di xamarin, utilizzare questo codice per ottenere il nome e il codice della versione

1) Nome versione:

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

2) Codice versione:

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

Se vuoi usarlo su XML allora aggiungi la riga sotto sul tuo file Gradle:

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

E poi usalo sul tuo XML in questo modo:

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

No, non devi fare nulla con AndroidManifest.xml

Fondamentalmente il nome e il codice della versione della tua app all'interno del file di gradle a livello di app , sotto il tag defaultConfig :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Nota: quando desideri caricare un'app nel playstore, puoi assegnare qualsiasi nome come nome della versione ma il codice della versione deve essere diverso dal codice della versione corrente se questa app è già nel Play Store.

Usa semplicemente il seguente frammento di codice per ottenere il codice della versione e il nome della versione da qualsiasi punto della tua app:

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

per Api 28 PackageInfo.versionCode è obsoleto, quindi utilizzare questo codice di seguito:

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

Fallo sempre con il try catchblocco:

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

Ecco il metodo per ottenere il codice versione:

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

Ho risolto questo usando la classe di preferenza.

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

Ci sono alcuni modi per ottenere versionCodee a livello di versionNamecodice.

1. Ottieni la versione da PackageManager. Questo è il modo migliore per la maggior parte dei casi.

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

2. Ottieni da generato BuildConfig.java. Si noti, tuttavia, che se si accede a questi valori nella libreria verrà restituita la versione della libreria, non le app, che utilizza questa libreria. Quindi utilizzare solo in progetti non di biblioteca!

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

Ci sono alcuni dettagli, ad eccezione dell'uso del secondo modo nel progetto di biblioteca. Nel nuovo plug-in Android Gradle (3.0.0+) sono state rimosse alcune funzionalità . Quindi, per ora, vale a dire impostare versioni diverse per sapori diversi che non funzionano correttamente.

Modo errato:

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
}

Il codice sopra imposterà correttamente i valori BuildConfig, ma da PackageManagerriceverai 0e nullse non hai impostato la versione nella defaultconfigurazione. Quindi la tua app avrà0 codice della versione sul dispositivo.

Esiste una soluzione alternativa: impostare apkmanualmente la versione per il file di output :

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

Questo codice è stato menzionato sopra a pezzi ma qui è di nuovo tutto incluso. È necessario un blocco try / catch perché potrebbe generare un "NameNotFoundException".

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

Spero che questo semplifichi le cose per qualcuno lungo la strada. :)

Qualcuno che non ha bisogno delle informazioni di BuildConfig per l'interfaccia utente dell'applicazione desidera comunque utilizzare queste informazioni per impostare una configurazione del lavoro CI o altri, come me.

Esiste un file generato automaticamente, BuildConfig.java, nella directory del progetto, purché il progetto venga compilato correttamente.

{} WORKSPACE / build / generata / source / buildConfig / {debug | rilascio} / {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";
}

Dividi le informazioni che ti servono per lo script python o altri strumenti. Ecco un esempio:

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)

Per favore, scusa la mia conoscenza limitata dell'inglese, ma spero che questo aiuti.

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

    }

  }
}

prova questo:

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

Primo:

import android.content.pm.PackageManager.NameNotFoundException;

e quindi usa questo:

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

Esempio per l'utilizzo all'interno del frammento.

        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

Esempio di 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())
    }
}

Non ringraziare :-)

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

Dato che dovevo ottenere solo il codice della versione e controllare se l'app è stata aggiornata o meno, in caso affermativo, ho dovuto avviare il playstore per aggiornarne uno. L'ho fatto in questo modo.

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

}

Quindi ho salvato il codice della versione usando le preferenze condivise creando una 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
     }
   }

Come nel 2020: l'API 28 "versionCode" è obsoleto, quindi possiamo usare "longVersionCode"

Codice di esempio in 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
        }

Utile per i sistemi di compilazione: esiste un file generato con il tuo apk chiamato output.json che contiene una matrice di informazioni per ciascun APK generato, inclusi versionName e versionCode.

per esempio

[
    {
        "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": {}
    }
]