ඔබගේ ඇන්ඩ්‍රොයිඩ් යෙදුමේ බිල්ඩ් / අනුවාද අංකය ලබා ගන්නේ කෙසේද?

මගේ ඇන්ඩ්‍රොයිඩ් යෙදුම සඳහා බිල්ඩ් අංකයක් ලබා ගන්නේ කෙසේද සහ සාදා ගන්නේ කෙසේදැයි මට දැනගත යුතුය. 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 අනුවාදය අනුව, අනුවාද කේතය සහ අනුවාදයේ නම ස්ථිතිකව ලබා ගත හැකිය 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 ඇල්ෆා එක්ස්ට්‍රීම්!" හෝ ඕනෑම දෙයක්.

උදාහරණයක්:

කොට්ලින්:

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නම් කියවන්න.

මගේ ශ්‍රේණියේ ගොඩනැගීමේ ගොනුවේ (මම ANT සිට Gradle වෙත සංක්‍රමණය විය) 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ගොනුව, ඔවුන් එහි නම්.

ස්කොට්යාබ් (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();
}

දැන් ඔබට අනුවාදයේ නම myVersionNameනූල් වලින් ලැබී ඇති බැවින් , ඔබට එය පෙළ දර්ශනයකට හෝ ඔබ කැමති ඕනෑම දෙයකට සැකසිය හැකිය ..

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

ඔබගේ උපාංග සූදානම් කිරීමේ අවස්ථාවෙහිදී , පහත කේතය එක් කරන්න:

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

මෙතැනින් සහ මෙතැනින් උපුටා ගන්නා ලද්දකි .

කොට්ලින් එක් ලයිනර්

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

BuildConfigඔබේ පන්තියට ආනයනය කිරීමට වග බලා ගන්න .

ජාවා වන්-ලයිනර්

String versionCode = String.valueOf(BuildConfig.VERSION_CODE);
String versionName = String.valueOf(BuildConfig.VERSION_NAME);

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 හි භාවිතා කිරීමට අවශ්‍ය නම් ඔබේ ශ්‍රේණියේ ගොනුවේ පහත පේළිය එක් කරන්න:

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 සමඟ කිසිවක් කිරීමට අවශ්‍ය නැත

මූලික වශයෙන් ඔබේ යෙදුමේ අනුවාදය නම සහ අනුවාදය කේතය තුල යෙදුම මට්ටමේ gradle ගොනුව, යටතේ defaultConfig ටැගය:

defaultConfig {  
   versionCode 1  
   versionName "1.0"  
}  

සටහන: ඔබ ප්ලේස්ටෝර් හි යෙදුම උඩුගත කිරීමට කැමති විට ඕනෑම නමක් අනුවාද නාමයක් ලෙස ලබා දිය හැකි නමුත් මෙම යෙදුම දැනටමත් ක්‍රීඩා වෙළඳසැලේ තිබේ නම් අනුවාද කේතය වත්මන් අනුවාද කේතයට වඩා වෙනස් විය යුතුය.

ඔබගේ යෙදුමේ ඕනෑම තැනක සිට අනුවාද කේතය සහ අනුවාදයේ නම ලබා ගැනීමට පහත කේත ස්නිපටය භාවිතා කරන්න:

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

මනාප පන්තිය භාවිතා කිරීමෙන් මට මෙය විසඳා ඇත.

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. ජනනය කිරීමෙන් එය ලබා ගන්න 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, නමුත් 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 {
   String appVersion = getPackageManager().getPackageInfo(getPackageName(), 0).versionName;
} catch (PackageManager.NameNotFoundException e) {e.printStackTrace();}

පාරේ යන කෙනෙකුට මෙය සරල කරයි කියා මම බලාපොරොත්තු වෙමි. :)

යෙදුමේ UI සඳහා BuildConfig තොරතුරු අවශ්‍ය නොවන අයෙකුට කෙසේ වෙතත් CI රැකියා වින්‍යාසයක් සැකසීමට හෝ මා වැනි වෙනත් අයට මෙම තොරතුරු භාවිතා කිරීමට අවශ්‍යය.

ඔබ ඔබේ ව්‍යාපෘතිය සාර්ථකව ගොඩනඟන තාක් කල් ඔබේ ව්‍යාපෘති නාමාවලිය යටතේ ස්වයංක්‍රීයව ජනනය කරන ලද ගොනුවක් වන BuildConfig.java ඇත.

OR WORKSPACE build / 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())
    }
}

ස්තූතියි එපා :-)

2020 දී මෙන්: API 28 "versionCode" ඉවත් කර ඇති බැවින් අපට "longVersionCode" භාවිතා කළ හැකිය.

කොට්ලින්හි නියැදි කේතය

  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
        }

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

}

පසුව මම උපයෝගීතා පන්තියක් නිර්මාණය කිරීමෙන් හවුල් මනාපයන් භාවිතා කරමින් අනුවාද කේතය සුරකිමි.

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

ගොඩනැඟීමේ පද්ධති සඳහා ප්‍රයෝජනවත්: ඔබේ APK සමඟ ජනනය කරන ලද ගොනුවක් ඇත output.json, එහි අනුවාද නාමය සහ අනුවාද කේතය ඇතුළුව උත්පාදනය කරන ලද සෑම 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": {}
    }
]