Jak uzyskać numer kompilacji / wersji aplikacji na Androida?

Muszę dowiedzieć się, jak uzyskać lub utworzyć numer kompilacji dla mojej aplikacji na Androida. Potrzebuję numeru kompilacji do wyświetlenia w interfejsie użytkownika.

Czy muszę coś z tym zrobić AndroidManifest.xml?

Posługiwać się:

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

Za pomocą tego możesz uzyskać kod wersji

int verCode = pInfo.versionCode;

Jeśli używasz wtyczki Gradle / Android Studio, od wersji 0.7.0 kod wersji i nazwa wersji są dostępne statycznie w BuildConfig. Upewnij się, że importujesz pakiet aplikacji , a nie inny BuildConfig:

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

Nie potrzebny obiekt kontekstowy!

Upewnij się również, że określono je w build.gradlepliku zamiast AndroidManifest.xml.

defaultConfig {
    versionCode 1
    versionName "1.0"
}

Nieco krótsza wersja, jeśli chcesz tylko nazwę wersji.

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

Potrzebne są dwie części: android: wersjaKod android: wersjaNazwa

versionCode to liczba i każda wersja aplikacji przesłanej do usługi Market musi mieć wyższą liczbę niż ostatnia.

VersionName jest ciągiem znaków i może być dowolną wartością. Tutaj definiujesz swoją aplikację jako „1.0”, „2.5” lub „2 Alpha EXTREME!” lub cokolwiek.

Przykład:

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)

Jawa:

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

Korzystanie z Gradle i BuildConfig

Pobieranie VERSION_NAME z BuildConfig

BuildConfig.VERSION_NAME

Tak, teraz to takie proste.

Czy zwraca pusty ciąg dla VERSION_NAME?

Jeśli otrzymujesz pusty ciąg znaków, BuildConfig.VERSION_NAMEczytaj dalej.

Ciągle otrzymywałem pusty ciąg, BuildConfig.VERSION_NAMEponieważ nie versionNameustawiałem pliku kompilacji Grade (migrowałem z ANT do Gradle). Oto instrukcje, jak upewnić się, że ustawiasz VERSION_NAMEza pośrednictwem 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}"
  }

}

Uwaga: pochodzi od mistrzowskiego Jake'a Whartona .

Usuwanie versionNamei versionCodezAndroidManifest.xml

A ponieważ teraz ustawiłeś plik versionNamei versionCodew build.gradlepliku, możesz również usunąć je ze swojego AndroidManifest.xmlpliku, jeśli tam są.

Oto czyste rozwiązanie oparte na rozwiązaniu scottyab (pod redakcją Xavi). Pokazuje, jak najpierw uzyskać kontekst, jeśli nie jest udostępniony przez twoją metodę. Ponadto wykorzystuje wiele linii zamiast wywoływać wiele metod na linię. Ułatwia to debugowanie aplikacji.

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

Teraz, gdy otrzymałeś nazwę wersji w ciągu myVersionName, możesz ustawić ją na TextView lub cokolwiek chcesz.

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

Aby uzyskać wersję aplikacji lub kod kompilacji, który służy do identyfikowania apka według kodu wersji. Kod wersji służy do wykrywania faktycznej konfiguracji kompilacji w momencie aktualizacji, publikacji itp.

int versionCode = BuildConfig.VERSION_CODE;

Nazwa wersji służy do wyświetlania użytkowników lub programistów sekwencji programowania. Możesz dodać dowolną nazwę wersji, jak chcesz

String versionName = BuildConfig.VERSION_NAME;

Użyj klasy BuildConfig

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

build.gradle (aplikacja)

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

Jeśli używasz PhoneGap, utwórz niestandardową wtyczkę PhoneGap:

Utwórz nową klasę w pakiecie aplikacji:

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

W plugins.xml dodaj następujący wiersz:

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

W zdarzeniu już przygotowanym do urządzenia dodaj następujący kod:

var PackageManagerPlugin = function() {

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

Następnie można uzyskać atrybut versionName, wykonując:

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

Pochodzi tu i tutaj .

Jedlinianki Kotlin

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

Pamiętaj, aby zaimportować BuildConfigdo swojej klasy

W przypadku użytkowników Xamarin użyj tego kodu, aby uzyskać nazwę i kod wersji

1) Nazwa wersji:

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

2) Kod wersji:

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

Jeśli chcesz go użyć na xml, dodaj poniższy wiersz do pliku gradle:

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

A następnie użyj go na swoim xml w następujący sposób:

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

Nie, nie musisz nic robić z AndroidManifest.xml

Zasadniczo nazwa wersji aplikacji i kod wersji w pliku ocen poziomu aplikacji , pod tagiem defaultConfig :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

Uwaga: jeśli chcesz załadować aplikację w sklepie playstore, możesz podać dowolną nazwę jako nazwę wersji, ale kod wersji musi być inny niż bieżący kod wersji, jeśli ta aplikacja jest już w sklepie Play.

Wystarczy użyć następującego fragmentu kodu, aby uzyskać kod wersji i nazwę wersji z dowolnego miejsca w aplikacji:

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

w przypadku interfejsu API 28 PackageInfo.versionCode jest przestarzały, więc użyj tego kodu poniżej:

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

Zawsze rób to z try catchblokiem:

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

Oto metoda uzyskania kodu wersji:

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

Rozwiązałem to za pomocą klasy preferencji.

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

Istnieje kilka sposobów na uzyskanie versionCodei versionNameprogramowo.

1. Pobierz wersję z PackageManager. Jest to najlepszy sposób w większości przypadków.

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

2. Pobierz z wygenerowanego BuildConfig.java. Ale zauważ, że jeśli uzyskasz dostęp do tych wartości w bibliotece, zwróci wersję biblioteki, a nie aplikacji, która korzysta z tej biblioteki. Dlatego używaj tylko w projektach niebibliotecznych!

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

Istnieje kilka szczegółów, z wyjątkiem użycia drugiego sposobu w projekcie biblioteki. W nowej wtyczce stopniowej Androida (3.0.0+) niektóre funkcje zostały usunięte . Na razie, tj. Ustawienie innej wersji dla różnych smaków nie działa poprawnie.

Niepoprawny sposób:

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
}

Powyższy kod poprawnie ustawi wartości w BuildConfig, ale od PackageManagerotrzymasz 0i nulljeśli nie ustawiłeś wersji w defaultkonfiguracji. Twoja aplikacja będzie mieć0 kod wersji na urządzeniu.

Istnieje obejście - apkręczne ustawienie wersji pliku wyjściowego :

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

Ten kod został wspomniany powyżej w częściach, ale tutaj jest ponownie uwzględniony. Potrzebujesz bloku try / catch, ponieważ może on wygenerować „NameNotFoundException”.

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

Mam nadzieję, że uprości to komuś na drodze. :)

Ktoś, kto nie potrzebuje informacji BuildConfig dla interfejsu użytkownika aplikacji, chce jednak użyć tych informacji do ustawienia konfiguracji zadania CI lub innych, takich jak ja.

W katalogu projektu znajduje się automatycznie wygenerowany plik BuildConfig.java, o ile pomyślnie zbudujesz projekt.

{WORKSPACE} / build / wygenerowane / 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";
}

Podziel potrzebne informacje według skryptu Python lub innych narzędzi. Oto przykład:

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)

Proszę wybaczyć moją ograniczoną znajomość języka angielskiego, ale mam nadzieję, że to pomoże.

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

    }

  }
}

Spróbuj tego:

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

Pierwszy:

import android.content.pm.PackageManager.NameNotFoundException;

a następnie użyj tego:

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

Przykład użycia fragmentu wewnątrz.

        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

Przykład Kotlina:

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

Nie dziękuj :-)

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

Ponieważ musiałem uzyskać tylko kod wersji i sprawdzić, czy aplikacja jest zaktualizowana, czy nie, jeśli tak, musiałem uruchomić playstore, aby go zaktualizować. Zrobiłem w ten sposób.

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

}

Następnie zapisałem kod wersji, korzystając z preferencji wspólnych, tworząc klasę 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
     }
   }

Podobnie jak w 2020 r .: API 28 „versionCode” jest przestarzałe, więc możemy użyć „longVersionCode”

Przykładowy kod w 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
        }

Przydatny w systemach kompilacji: plik o nazwie generowany jest z apk output.json który zawiera tablicę informacji dla każdego wygenerowanego APK, w tym nazwę wersji i kod wersji.

na przykład

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