Android 애플리케이션의 빌드 / 버전 번호를 얻는 방법은 무엇입니까?

내 Android 응용 프로그램의 빌드 번호를 얻거나 만드는 방법을 알아야합니다. UI에 표시하려면 빌드 번호가 필요합니다.

내가 뭔가를해야 AndroidManifest.xml합니까?

사용하다:

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

그리고 이것을 사용하여 버전 코드를 얻을 수 있습니다

int verCode = pInfo.versionCode;

버전 0.7.0 부터 Gradle 플러그인 / Android Studio를 사용중인 경우 버전 코드 및 버전 이름은에서 정적으로 사용할 수 있습니다 BuildConfig. 다른 패키지가 아닌 앱 패키지를 가져와야합니다BuildConfig .

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

컨텍스트 객체가 필요하지 않습니다!

또한 build.gradle파일 대신 파일 에 지정 하십시오 AndroidManifest.xml.

defaultConfig {
    versionCode 1
    versionName "1.0"
}

버전 이름 만 원하면 약간 더 짧은 버전입니다.

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

필요한 두 부분이 있습니다 : android : versionCode android : versionName

versionCode는 숫자이며 마켓에 제출하는 모든 버전의 앱은 마지막 버전보다 높은 숫자를 가져야합니다.

VersionName은 문자열이며 원하는 것이 될 수 있습니다. 여기에서 앱을 "1.0"또는 "2.5"또는 "2 Alpha EXTREME!"로 정의합니다. 또는 무엇이든.

예:

코 틀린 :

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)

자바:

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

Gradle 및 BuildConfig 사용

BuildConfig에서 VERSION_NAME 가져 오기

BuildConfig.VERSION_NAME

그렇습니다, 지금은 쉽습니다.

VERSION_NAME에 대해 빈 문자열을 반환합니까?

빈 문자열이 표시되면 BuildConfig.VERSION_NAME계속 읽으십시오.

Grade 빌드 파일에서 ANT를 BuildConfig.VERSION_NAME설정하지 않았기 때문에 빈 문자열이 계속 나타납니다 versionName(ANT에서 Gradle로 마이그레이션). 따라서 VERSION_NAMEGradle을 통해 비아를 설정하는 데 필요한 지침이 있습니다 .

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

}

참고 : 이것은 훌륭한 Jake Wharton의 것 입니다.

제거 versionName및 versionCode에서AndroidManifest.xml

그리고 파일에 versionNameand versionCode를 설정 했으므로 build.gradle파일 에서 파일을 제거 할 수도 있습니다 ( AndroidManifest.xml있는 경우).

다음은 scottyab 솔루션 (Xavi에서 편집)을 기반으로 한 깨끗한 솔루션 입니다. 메소드가 제공하지 않는 경우 컨텍스트를 먼저 얻는 방법을 보여줍니다. 또한 한 줄에 여러 메서드를 호출하는 대신 여러 줄을 사용합니다. 따라서 응용 프로그램을 디버깅해야 할 때 더 쉽습니다.

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

이제 String에서 버전 이름을 받았 myVersionName으므로 TextView 또는 원하는 이름으로 설정할 수 있습니다.

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

버전 코드로 APK를 식별하는 데 사용되는 앱 버전 또는 빌드 코드를 가져옵니다. 버전 코드는 업데이트, 게시 등의 시점에서 실제 빌드 구성을 감지하는 데 사용됩니다.

int versionCode = BuildConfig.VERSION_CODE;

버전 이름은 개발 순서의 사용자 또는 개발자를 표시하는 데 사용됩니다. 원하는대로 모든 종류의 버전 이름을 추가 할 수 있습니다

String versionName = BuildConfig.VERSION_NAME;

BuildConfig 클래스 사용

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

build.gradle (앱)

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

PhoneGap을 사용하는 경우 사용자 정의 PhoneGap 플러그인을 작성하십시오.

앱 패키지에서 새 클래스를 만듭니다.

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

plugins.xml에서 다음 행을 추가하십시오.

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

당신에 deviceready 이벤트 , 다음 코드를 추가합니다 :

var PackageManagerPlugin = function() {

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

그런 다음 다음을 수행하여 versionName 속성을 얻을 수 있습니다.

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

여기 와 여기 에서 파생 됩니다 .

코 틀린 원 라이너

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

BuildConfig수업 으로 가져와야 합니다

xamarin 사용자의 경우이 코드를 사용하여 버전 이름 및 코드를 가져 오십시오.

1) 버전 이름 :

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

2) 버전 코드 :

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

xml에서 사용하려면 gradle 파일에 아래 줄을 추가하십시오.

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

그런 다음 XML에서 다음과 같이 사용하십시오.

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

아니요, AndroidManifest.xml로 아무것도 할 필요가 없습니다.

기본적으로 defaultConfig 태그 아래 앱 레벨 gradle 파일 내의 앱 버전 이름 및 버전 코드 :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

참고 : Playstore에 앱을 업로드하려는 경우 이름을 버전 이름으로 지정할 수 있지만이 앱이 이미 Play Store에있는 경우 버전 코드는 현재 버전 코드와 달라야합니다.

다음 코드 스 니펫을 사용 하여 앱 어디에서나 버전 코드 및 버전 이름 을 얻으 십시오.

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

Api 28의 경우 PackageInfo.versionCode는 더 이상 사용되지 않으므로 아래 코드를 사용하십시오.

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

항상 try catch블록으로 수행하십시오 .

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

버전 코드를 얻는 방법은 다음과 같습니다.

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

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

얻을 수있는 몇 가지 방법이 있습니다 versionCode및 versionName프로그램은.

1. 에서 버전을 가져옵니다 PackageManager. 대부분의 경우 가장 좋은 방법입니다.

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

2. generated에서 가져옵니다 BuildConfig.java. 그러나 라이브러리에서이 값에 액세스하면이 라이브러리를 사용하는 앱 버전이 아닌 라이브러리 버전이 반환됩니다. 따라서 비 라이브러리 프로젝트에서만 사용하십시오!

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

라이브러리 프로젝트에서 두 번째 방법을 사용하는 것을 제외하고 몇 가지 세부 사항이 있습니다. 새로운 안드로이드 gradle 플러그인 (3.0.0+)에서 일부 기능이 제거되었습니다 . 따라서 현재로서는 다른 맛을 위해 다른 버전을 설정하면 제대로 작동하지 않습니다.

잘못된 방법 :

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
}

위의 코드는 제대로의 값을 설정합니다 BuildConfig,하지만에서 PackageManager당신이 받게됩니다 0하고 null당신이 설정 버전하지 않았다 경우 default구성. 따라서 앱의 0기기에 버전 코드 가 있습니다 .

해결 방법-출력 apk파일의 버전을 수동으로 설정 하십시오.

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

이 코드는 위에서 언급되었지만 여기에 다시 모두 포함되어 있습니다. "NameNotFoundException"이 발생할 수 있으므로 try / catch 블록이 필요합니다.

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

나는 이것이 길 아래 누군가를 위해 일을 단순화하기를 바랍니다. :)

그러나 응용 프로그램 UI에 BuildConfig 정보가 필요하지 않은 사람은 CI 작업 구성이나 다른 사람을 설정하는 데이 정보를 사용하려고합니다.

프로젝트를 성공적으로 빌드하는 한 프로젝트 디렉토리 아래에 자동으로 생성 된 BuildConfig.java 파일이 있습니다.

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

파이썬 스크립트 또는 기타 도구로 필요한 정보를 분할하십시오. 예를 들면 다음과 같습니다.

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)

제한된 영어 실력을 용서해주십시오. 그러나 이것이 도움이되기를 바랍니다.

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

    }

  }
}

이거 한번 해봐:

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

먼저:

import android.content.pm.PackageManager.NameNotFoundException;

그리고 이것을 사용하십시오 :

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

내부 조각 사용 예입니다.

        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

코 틀린 예 :

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

고마워요 :-)

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

버전 코드 만 가져 와서 앱의 업데이트 여부를 확인해야한다면 업데이트 된 버전을 얻으려면 플레이 스토어를 시작해야했습니다. 나는 이렇게했다.

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

}

그런 다음 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
     }
   }

2020 년과 같이 : API 28 "versionCode"는 더 이상 사용되지 않으므로 "longVersionCode"를 사용할 수 있습니다

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
        }

빌드 시스템에 유용 : apk로 생성 된 파일이 output.json있으며 versionName 및 versionCode를 포함하여 생성 된 각 APK에 대한 정보 배열이 포함되어 있습니다.

예 :

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