अपने Android एप्लिकेशन का बिल्ड / संस्करण नंबर कैसे प्राप्त करें?

Question

मुझे यह पता लगाने की आवश्यकता है कि अपने एंड्रॉइड एप्लिकेशन के लिए बिल्ड नंबर कैसे प्राप्त करें या बनाएं। मुझे UI में प्रदर्शित करने के लिए बिल्ड नंबर की आवश्यकता है।

क्या मुझे कुछ करना है AndroidManifest.xml?

Comments

निश्चित नहीं है, लेकिन मुझे लगता है कि आप इसे AndroidManifest.xml फ़ाइल पार्स करके प्राप्त कर सकते हैं।

— सुनीत कुमार गुप्ता

डुप्लिकेटेड: stackoverflow.com/questions/4471025/…

— xpto

संस्करण कोड का उपयोग int versionCode = BuildConfig.VERSION_CODE;करने के लिए और संस्करण का नाम पाने के लिएString versionName = BuildConfig.VERSION_NAME;

— लुकास

Answer 1

उपयोग:

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

और आप इसका उपयोग करके संस्करण कोड प्राप्त कर सकते हैं

int verCode = pInfo.versionCode;

Comments

@ फेलिक्स को आप संदर्भ के बाहर getPackageManager () नहीं कह सकते हैं, इसलिए getApplicationContext () (या पारित संदर्भ) की आवश्यकता हो सकती है।

— सेवर

क्या होगा यदि आपको कुछ स्थिर विधि के अंदर इस संख्या की आवश्यकता है जहां आप संदर्भ को पारित नहीं कर सकते हैं? मेरी ओर से बुरा डिजाइन?

— गुबट्रॉन

और try... catch..जब भूल न करेंgetPackageInfo()

— जुलाब

@Gubatron नीचे दिए गए मेरे उत्तर को इन मूल्यों को सांख्यिकीय रूप से प्राप्त करने की अनुमति देता है।

— सैम डोजर

यदि आप केवल एप्लिकेशन का संस्करण प्राप्त करना चाहते हैं तो यह दो संकलित है। आपको यहांBuildConfig.VERSION_** सुझाए अनुसार उपयोग करना चाहिए ।

— टिमो बैहर

Answer 2

यदि आप ग्रैडल प्लगइन / एंड्रॉइड स्टूडियो का उपयोग कर रहे हैं, तो संस्करण 0.7.0 के रूप में , संस्करण कोड और संस्करण का नाम सांख्यिकीय रूप से उपलब्ध है 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"
}

Comments

यह वास्तव में सभी संदर्भ और पैकेज मैनेजर की तुलना में बहुत बेहतर है, धन्यवाद।

— सुपरजग्यू

दरअसल Android Studio लॉन्च होने के बाद यह सबसे अच्छा उपाय है !!! मेरी ओर से +1

— ध्रुविल पटेल

यह बहुत विश्वसनीय नहीं है। संस्करण नाम ज्यादातर समय एक खाली स्ट्रिंग के रूप में दिखाई देता है।

— बिनॉय बाबू

@BinoyBabu इसे कभी भी एक खाली स्ट्रिंग के रूप में नहीं दिखाना चाहिए यदि आपने versionNameअपनी build.gradleफ़ाइल में अपने ऐप के लिए निर्दिष्ट किया है ।

— सैम डोजर

काम करने के लिए आपको सही पैकेज आयात करने की आवश्यकता होगी:import com.yourapppackage.android.BuildConfig

— एरिक बी।

Answer 3

यदि आप केवल संस्करण नाम चाहते हैं तो थोड़ा कम संस्करण।

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

Comments

अति उत्कृष्ट। यह शायद NameNotFoundException के लिए कोशिश / पकड़ के साथ घिरा होना चाहिए।

— इगोरगानापोलस्की

+1 मैंने आपका समाधान लागू किया है जो बहुत अच्छा काम करता है! हालाँकि, इस समाधान को इगोर ने कहा और पकड़ने की कोशिश में घिरा होना चाहिए और यह अच्छा अभ्यास है (जैसे डिबगिंग के लिए) प्रत्येक विधि को कॉल करने के बजाय एक अलग लाइन पर कॉल करना है। एक लाइन पर। इसलिए मैंने नीचे

— माइकल

यह सही समाधान है, धन्यवाद;) लेकिन, जैसा कि @IgorGanapolsky द्वारा सुझाया गया है, इसे कोशिश के साथ घेरना होगा / पकड़ना होगा :)

— andrea.rinaldi

ग्रैडल का उपयोग करने वालों के लिए - एक सरल उपाय है। नीचे मेरा जवाब देखें।

— सैम डोजर

@Erwinus मैं इस तरह के सामान को पकड़ने के लिए एक सामान्य अपवाद का उपयोग करने की धारणा से पूरी तरह असहमत हूं। अधिक महीन दाने वाले अपवाद संभावित त्रुटियों की एक डेवलपर की समझ को प्रदर्शित करते हैं।

— इगोरगानापोलस्की

Answer 4

आपके लिए आवश्यक दो भाग हैं: android: versionCode Android: versionName

वर्जनकोड एक नंबर है, और आपके द्वारा मार्केट में सबमिट किए गए ऐप के हर संस्करण के लिए एक उच्च संख्या और फिर अंतिम होना आवश्यक है।

वर्जननाम एक स्ट्रिंग है, और ऐसा कुछ भी हो सकता है जिसे आप चाहते हैं। यह वह जगह है जहाँ आप अपने ऐप को "1.0" या "2.5" या "2 अल्फा एक्सट्रीम" के रूप में परिभाषित करते हैं! जो कुछ भी।

उदाहरण:

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)

जावा:

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

Comments

के एंड्रॉयड की आधिकारिक विवरण android:versionCodeऔर android:versionNameयहां पाया जा सकता: developer.android.com/tools/publishing/...

— Jeffro

इस मामले में यह प्रसंग

— .ie

जब आप कुछ सैंपल कोड पेस्ट करते हैं, तो मापदंडों के अर्थ को समझाने के लिए उपयोगी होता है ।... वैसे तो हर कोई समझ सकता है कि आप क्या this.getPackageName()प्रतिनिधित्व करते हैं, 0बस थूक का मतलब के बारे में कोई सुराग नहीं है

— राफेल लीमा

एंड्रॉइड स्टूडियो का दावा है कि वर्जनकोड हटा दिया गया है

— रोमन घेरता

@RomanGherta यह एपीआई 28 के रूप में है। यदि आप कुछ भी कम (या 8 साल पहले जब यह जवाब लिखा गया था) का उपयोग करके कोड लिख रहे हैं, तो आपको अभी भी अच्छा होना चाहिए। यहां एक और जवाब में अद्यतन विधि है।

— मेरकिडैमिस

Answer 5

ग्रैडल और बिल्डकॉनफिग का उपयोग करना

BuildConfig से VERSION_NAME प्राप्त करना

BuildConfig.VERSION_NAME

हां, यह अब आसान है।

क्या यह VERSION_NAME के ​​लिए एक खाली स्ट्रिंग लौटा रहा है?

यदि आपको खाली स्ट्रिंग मिल रही है BuildConfig.VERSION_NAMEतो आगे पढ़ें।

मैं एक खाली स्ट्रिंग प्राप्त करता BuildConfig.VERSION_NAMEरहा क्योंकि मैं versionNameअपनी ग्रेड बिल्ड फ़ाइल में सेट नहीं कर रहा था (मैं एएनटी से ग्रैडल में चला गया)। इसलिए, यह सुनिश्चित करने के लिए निर्देश दिए गए हैं कि आप VERSION_NAMEग्रेडल के माध्यम से अपनी सेटिंग कर रहे हैं ।

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

}

नोट: यह मास्टर जेक व्हार्टन का है ।

से versionNameऔर निकाल रहा versionCodeहैAndroidManifest.xml

और चूंकि आप निर्धारित किया है versionNameऔर versionCodeमें build.gradleअब फ़ाइल, आप भी उन्हें अपने से निकाल सकते हैं AndroidManifest.xmlफ़ाइल है, अगर वे कर रहे हैं।

Comments

जब तक आप एप्लिकेशन प्रोजेक्ट से BuildConfig तक पहुंच रहे हैं, तब तक यह बहुत अच्छा काम करता है, न कि एप्लिकेशन प्रोजेक्ट में उपयोग की जाने वाली लाइब्रेरी। अन्यथा, आपको लाइब्रेरी प्रोजेक्ट के लिए BuildConfig मिलेगा, न कि एप्लिकेशन।

— जॉन कमिंग्स

@JohnCummings दिलचस्प ... ऐसा नहीं सोचा था।

— जोशुआ पिंटर

बिल्कुल काम नहीं कर रहा है versionName "1.2", और BuildConfig.VERSION_NAMEवापस लौटें empty। एपीआई> 21

— सोजतीन

एक अनुवर्ती के रूप में, हम वास्तव में सिर्फ एक स्थिर पूर्णांक के पक्ष में इस विधि और के लिए एक स्थिर स्ट्रिंग उपयोग बंद कर दिया versionCodeऔर versionName, क्रमशः। केवल इसलिए कि कोड पुश जैसे कुछ उपकरण आपकी build.gradleफ़ाइल को पार्स करके आपके संस्करण की संख्या प्राप्त करने का प्रयास करते हैं और वे एक गतिशील मूल्य को पूरा नहीं कर सकते हैं।

— जोशुआ पिंटर

@JoshuaPinter पैकेज मैनजर वास्तव में सबसे सुरक्षित विकल्प है। यदि आप स्प्लिट्स के लिए वर्जन कोड ओवरराइड्स का उपयोग करते हैं बिल्डकॉनफीग स्थिरांक अभी भी मूल (यद्यपि स्वाद) मान रखता है।

— यूगेन पिंचेक

Answer 6

यहाँ एक साफ समाधान है , स्कॉटीटैब के समाधान पर आधारित है (जेवी द्वारा संपादित)। यह दिखाता है कि संदर्भ को पहले कैसे प्राप्त किया जाए, यदि यह आपकी विधि द्वारा प्रदान नहीं किया गया है। इसके अलावा यह प्रति लाइन कई तरीकों को कॉल करने के बजाय कई लाइनों का उपयोग करता है। इससे आपको अपने एप्लिकेशन को डिबग करना आसान हो जाता है।

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

अब जब आपको स्ट्रिंग में संस्करण का नाम प्राप्त हुआ myVersionName, तो आप इसे टेक्स्ट व्यू या जो भी आपको पसंद हो, उस पर सेट कर सकते हैं।

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

Comments

क्या आपको लगता है कि एनएनएफई को वास्तव में फेंक दिया जा सकता है? पैकेज मैनेजर में रनिंग एप्लिकेशन न मिलना अजीब होगा :)

— TWiStErRob

मैं आपके साथ हूं कि यह अजीब हो सकता है, लेकिन यह इस पद्धति का डिफ़ॉल्ट अपवाद है - एपीआई देखें : यह कहता है Throws PackageManager.NameNotFoundException if a package with the given name can not be found on the system.। हालाँकि, मैं उसके लिए एक परिदृश्य की कल्पना नहीं कर सकता था!

— माइकल

Answer 7

ऐप वर्जन प्राप्त करने या कोड बनाने के लिए जिसका उपयोग इसके वर्जन कोड द्वारा एपीके की पहचान करने के लिए किया जाता है। संस्करण कोड का उपयोग अपडेट, प्रकाशन आदि के समय वास्तविक बिल्ड कॉन्फ़िगरेशन का पता लगाने के लिए किया जाता है।

int versionCode = BuildConfig.VERSION_CODE;

संस्करण नाम का उपयोग उपयोगकर्ताओं या विकास अनुक्रम के डेवलपर्स को दिखाने के लिए किया जाता है। आप किसी भी तरह का वर्जन नाम जोड़ सकते हैं

String versionName = BuildConfig.VERSION_NAME;

Answer 8

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

Answer 9

यदि आप 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" />

अपने वसीयतनामे में , निम्नलिखित कोड जोड़ें:

var PackageManagerPlugin = function() {

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

फिर, आप वर्जननाम विशेषता प्राप्त कर सकते हैं:

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

यहाँ और यहाँ से व्युत्पन्न ।

Comments

सवाल PhoneGap के बारे में नहीं था। आपका जवाब लोगों को भ्रमित कर सकता है।

— 15

@BBJ कहीं भी प्रश्न, शीर्षक, या टैग में यह निर्दिष्ट नहीं करता है कि प्रश्न एक मूल आवेदन के बारे में था। यह वही है जो मैं जवाब के लिए खोज रहा था, जब मैं गूगल पर आया था, और मुझे कई घंटे बचाए थे।

— सीन हॉल

धन्यवाद Hall72215 मुझे इस पर खुशी होगी ... अगर वास्तव में आपके खुद के संस्करण की संख्या प्राप्त करने का कोई अन्य तरीका नहीं है? यदि संभव हो तो मैं एक प्लगइन से बचना चाहता हूँ!

— मैग्नस स्मिथ

@MagnusSmith तब तक नहीं जब तक फोनगैप / कॉर्डोवा ने इसे अपने कार्यों में नहीं जोड़ा।

— सीन हॉल

इस उदाहरण में आप देख सकते हैं कि ऐप्स बनाने के लिए तीसरे पक्ष के समाधान का उपयोग करना कितना मूर्खतापूर्ण है। जब आप इसे स्क्रैच से खुद लिखते हैं तो कोड करने के लिए बस कुछ ही लाइनें थीं।

— कोडबीट

Answer 10

कोटलीन वन-लाइनर्स

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

BuildConfigअपनी कक्षा में आयात करना सुनिश्चित करें

Answer 11

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

Answer 12

यदि आप इसे xml पर उपयोग करना चाहते हैं तो अपनी ग्रेडेल फ़ाइल पर नीचे की पंक्ति जोड़ें:

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

Comments

मैं अपने xml त्रुटि में हो रहा हूँ: प्रतीक @ 'string / versionName' को हल नहीं कर सकता

— RJB

Answer 13

नहीं, आपको AndroidManifest.xml के साथ कुछ भी करने की आवश्यकता नहीं है

मूल रूप से आपके ऐप का वर्जन नाम और वर्जन कोड अंदर ऐप लेवल ग्रेडल फाइल के अंदर , defaultConfig टैग के तहत :

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

नोट: जब आप playstore में ऐप अपलोड करना चाहते हैं, तो किसी भी नाम को संस्करण नाम दे सकते हैं, लेकिन अगर यह ऐप पहले से ही प्ले स्टोर में है, तो संस्करण कोड वर्तमान संस्करण कोड से अलग होना चाहिए।

बस अपने ऐप में कहीं से संस्करण कोड और संस्करण का नाम पाने के लिए निम्नलिखित कोड स्निपेट का उपयोग करें :

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

Comments

versionCode एपीआई 28 में पदावनत किया गया था। डॉक्स में कहा गया है, इसके बजाय longVersionCode का उपयोग करें; डेवलपर

— दान असामान्य

Answer 14

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

Answer 15

हमेशा इसे 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());
}

Answer 16

यहाँ संस्करण कोड प्राप्त करने की विधि है:

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

Comments

बेहतर विधि - BuildConfig.VERSION_CODE

— जयदेव

Answer 17

मैंने वरीयता वर्ग का उपयोग करके इसे हल किया है।

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

Answer 18

कुछ तरीके 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. इसे जनरेट से प्राप्त करें BuildConfig.java। लेकिन ध्यान दें, यदि आप इस मान को लाइब्रेरी में एक्सेस करेंगे तो यह लाइब्रेरी वर्जन को लौटाएगा, एप्स को नहीं, जो इस लाइब्रेरी का उपयोग करता है। तो केवल गैर-पुस्तकालय परियोजनाओं में उपयोग करें!

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

---

पुस्तकालय परियोजना में दूसरे तरीके का उपयोग करने के अलावा कुछ विवरण हैं। नए android gradle plugin (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
    }
}

Answer 19

इस कोड को टुकड़ों में ऊपर उल्लेख किया गया था, लेकिन यहां इसे फिर से शामिल किया गया है। आपको एक कोशिश / कैच ब्लॉक की आवश्यकता है क्योंकि यह "NameNotFoundException" को फेंक सकता है।

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

मुझे उम्मीद है कि यह सड़क के नीचे के लोगों के लिए चीजों को सरल करता है। :)

Answer 20

कोई है जो आवेदन की यूआई के लिए BuildConfig जानकारी की जरूरत नहीं है, लेकिन मेरे जैसे CI नौकरी विन्यास या अन्य की स्थापना के लिए इन जानकारी का उपयोग करना चाहता है।

जब तक आप अपनी परियोजना का सफलतापूर्वक निर्माण करते हैं, तब तक एक स्वचालित रूप से जेनरेट की गई फ़ाइल BuildConfig.java है।

{WORKSPACE} / निर्माण / उत्पन्न / स्रोत / buildConfig / {डिबग | रिहाई} / {पैकेज} /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)

कृपया मेरी सीमित अंग्रेजी क्षमता का बहाना करें, लेकिन आशा है कि इससे मदद मिलेगी।

Answer 21

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

    }

  }
}

Comments

हाय, @donmj यदि आप एंड्रॉइड डिवाइस के लिए अनधिकृत रूट का उपयोग कर रहे हैं। मैं बात करता हूं, आपको आवश्यकता होगी। यह मेरा दृष्टिकोण है।

— दारुल दल्कानत

मदद के लिए धन्यवाद @ दुरुल दल्कानत :)।

— डॉन

Answer 22

इसको आजमाओ:

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

Answer 23

प्रथम:

import android.content.pm.PackageManager.NameNotFoundException;

और फिर इस का उपयोग करें:

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

Comments

उसके लिए समय नहीं मिला।

— BlaShadow

Answer 24

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

Answer 25

फ्रैगमेंट उपयोग के अंदर का उदाहरण।

        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

Comments

आपको अपना उत्तर पोस्ट करने से पहले अन्य उत्तरों को देखना चाहिए। उदाहरण के लिए आप getActivity.getApplicationContext कर रहे हैं यदि आप खंड में हैं तो मैं समझ सकता हूं लेकिन यदि आप गतिविधि में हैं तो मुझे नहीं लगता कि आपको getActivity को कॉल करने की आवश्यकता होगी

— साहिल मनचंदा

मेरे मामले में मैंने यह बनाया है कि फ्रैगमेंट के लिए। कोड onCreate के अंदर उपयोग किया जाता है

— नीलमणि

Answer 26

कोटलिन उदाहरण:

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

धन्यवाद मत करो :-)

Answer 27

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

Answer 28

जैसा कि मुझे केवल संस्करण कोड प्राप्त करना था और जांचना होगा कि क्या ऐप अपडेट किया गया है या नहीं, यदि हां, तो मुझे अपडेट करने के लिए प्लेस्टोर लॉन्च करना होगा। मैंने इस तरह किया।

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

}

फिर मैंने एक उपयोग वर्ग बनाकर साझा वरीयता का उपयोग करके संस्करण कोड सहेजा।

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

Answer 29

जैसा कि 2020 में: एपीआई 28 "वर्जनकोड" को हटा दिया गया है, इसलिए हम "लॉन्गवेरोडकोड" का उपयोग कर सकते हैं

कोटलिन में नमूना कोड

  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
        }

Answer 30

बिल्ड सिस्टम के लिए उपयोगी: आपकी एपीके नामक एक फाइल जनरेट होती है output.json होती है जिसमें वर्जननाम और वर्जनकोड सहित प्रत्येक जेनरेट किए गए एपीके के लिए जानकारी की एक सरणी होती है।

जैसे

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