android - अपने एंड्रॉइड एप्लिकेशन का निर्माण / संस्करण संख्या कैसे प्राप्त करें?


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

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



Answers



उपयोग:

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

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

int verCode = pInfo.versionCode;



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



थोड़ा छोटा संस्करण अगर आप बस संस्करण नाम चाहते हैं

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



Gradle और BuildConfig का उपयोग करना

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

BuildConfig.VERSION_NAME

हां, ये अब इतना आसान है

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

यदि आप BuildConfig.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}"
  }

}

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

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

और जब से आपने build.gradle फ़ाइल में build.gradle और versionCode को सेट किया है, तो आप उन्हें अपने AndroidManifest.xml फ़ाइल से निकाल सकते हैं, अगर वे वहां हैं




आपको दो हिस्सों की आवश्यकता है: एंड्रॉइड: संस्करण कोड एंड्रॉइड: versionName

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

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

उदाहरण:

इसे कोड में पहुंचने के लिए, ऐसा कुछ करें:

PackageManager manager = this.getPackageManager();
PackageInfo info = manager.getPackageInfo(this.getPackageName(), 0);
Toast.makeText(this,
     "PackageName = " + info.packageName + "\nVersionCode = "
       + info.versionCode + "\nVersionName = "
       + info.versionName + "\nPermissions = " + info.permissions, Toast.LENGTH_SHORT).show();



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

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 में संस्करण का नाम प्राप्त किया है, तो आप इसे एक myVersionName सेट कर सकते हैं या जो भी आप चाहते हैं ..

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



यदि आप फोनगैप का उपयोग कर रहे हैं, तो कस्टम फोनगैप प्लगिन बनाएं:

अपने ऐप के पैकेज में एक नया वर्ग बनाएं:

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

यहां और यहां से प्राप्त किया गया




एक बहुत आसान तरीका है:

private String appVersion = BuildConfig.VERSION_NAME;



try catch ब्लॉक की try catch साथ हमेशा ऐसा 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;
}



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

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



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



यदि आप इसे एक्सएमएल पर उपयोग करना चाहते हैं तो अपने 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" />



किसी ऐसे व्यक्ति को एप्लिकेशन के UI के लिए BuildConfig जानकारी की आवश्यकता नहीं है, हालांकि, मुझे सीआई जॉब कॉन्फ़िगरेशन या अन्य लोगों की स्थापना के लिए इन सूचनाओं का उपयोग करना है।

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

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

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




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

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

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




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

    }

  }
}



प्रथम:

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



इसको आजमाओ:

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



अंदर के टुकड़े के उपयोग के उदाहरण

        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



versionCode और versionCode पाने के कुछ तरीके प्रोग्राममैटिक रूप से हैं

  1. PackageManager से संस्करण प्राप्त करें ज्यादातर मामलों में यह सबसे अच्छा तरीका है
try {
    String versionName = packageManager.getPackageInfo(packageName, 0).versionName;
    int versionCode = packageManager.getPackageInfo(packageName, 0).versionCode;
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}
  1. इसे उत्पन्न BuildConfig.java से प्राप्त करें लेकिन ध्यान दें, यदि आप लाइब्रेरी में इन मूल्यों का उपयोग करेंगे तो यह लाइब्रेरी संस्करण वापस नहीं लाएगा, न कि ऐप एक, जो कि इस लाइब्रेरी का उपयोग करता है। तो केवल गैर-पुस्तकालय परियोजनाओं में ही उपयोग करें!
String versionName = BuildConfig.VERSION_NAME;
int versionCode = BuildConfig.VERSION_CODE;

लाइब्रेरी प्रोजेक्ट में दूसरे तरीके के उपयोग के अलावा कुछ विवरण हैं नए एंड्रॉइड ग्रेडेल प्लगइन (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 में मानों को सही ढंग से सेट कर देगा, लेकिन BuildConfig से आप 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
    }
}