Obtenez le fichier .apk Android VersionName ou VersionCode SANS installer apk

Comment puis-je obtenir par programme le code de version ou le nom de version de mon apk à partir du fichier AndroidManifest.xml après l'avoir téléchargé et sans l'installer.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="xxx.xx.xxx"
    android:versionCode="1"
    android:versionName="1.1" >

Par exemple, je veux vérifier si une nouvelle version est téléchargée sur mon service IIS, après l'avoir installée sur l'appareil, s'il ne s'agit pas d'une nouvelle version, je ne veux pas l'installer.

La suite a fonctionné pour moi à partir de la ligne de commande:

aapt dump badging myapp.apk

REMARQUE: aapt.exe se trouve dans un build-toolssous-dossier du SDK. Par exemple:

<sdk_path>/build-tools/23.0.2/aapt.exe

final PackageManager pm = getPackageManager();
String apkName = "example.apk";
String fullPath = Environment.getExternalStorageDirectory() + "/" + apkName;        
PackageInfo info = pm.getPackageArchiveInfo(fullPath, 0);
Toast.makeText(this, "VersionCode : " + info.versionCode + ", VersionName : " + info.versionName , Toast.LENGTH_LONG).show();

Si vous utilisez la version 2.2 et supérieure d' Android Studio, dans Android Studio, utilisez Build → Analyze APKpuis sélectionnez le fichier AndroidManifest.xml.

aapt dump badging test.apk | grep "VersionName" | sed -e "s/.*versionName='//" -e "s/' .*//"

Cela répond à la question en renvoyant uniquement le numéro de version. Toutefois......

L'objectif, comme indiqué précédemment, devrait être de savoir si l'apk sur le serveur est plus récent que celui installé AVANT de tenter de le télécharger ou de l'installer. Le moyen le plus simple de le faire est d'inclure le numéro de version dans le nom de fichier de l'apk hébergé sur le serveur, par exemplemyapp_1.01.apk

Vous devrez établir le nom et le numéro de version des applications déjà installées (si elles sont installées) afin de faire la comparaison. Vous aurez besoin d'un périphérique rooté ou d'un moyen d'installer le binaire aapt et busybox s'ils ne sont pas déjà inclus dans la rom.

Ce script obtiendra la liste des applications de votre serveur et la comparera avec toutes les applications installées. Le résultat est une liste marquée pour la mise à niveau / l'installation.

#/system/bin/sh
SERVER_LIST=$(wget -qO- "http://demo.server.com/apk/" | grep 'href' | grep '\.apk' | sed 's/.*href="https://' | \
              sed 's/".*//' | grep -v '\/' | sed -E "s/%/\\\\x/g" | sed -e "s/x20/ /g" -e "s/\\\\//g")
LOCAL_LIST=$(for APP in $(pm list packages -f | sed -e 's/package://' -e 's/=.*//' | sort -u); do \
              INFO=$(echo -n $(aapt dump badging $APP | grep -e 'package: name=' -e 'application: label=')) 2>/dev/null; \
              PACKAGE=$(echo $INFO | sed "s/.*package: name='//" | sed "s/'.*$//"); \
              LABEL=$(echo $INFO | sed "s/.*application: label='//" | sed "s/'.*$//"); if [ -z "$LABEL" ]; then LABEL="$PACKAGE"; fi; \
              VERSION=$(echo $INFO | sed -e "s/.*versionName='//" -e "s/' .*//"); \
              NAME=$LABEL"_"$VERSION".apk"; echo "$NAME"; \
              done;)
OFS=$IFS; IFS=$'\t\n'
for REMOTE in $SERVER_LIST; do
    INSTALLED=0
    REMOTE_NAME=$(echo $REMOTE | sed 's/_.*//'); REMOTE_VER=$(echo $REMOTE | sed 's/^[^_]*_//g' | sed 's/[^0-9]*//g')
    for LOCAL in $LOCAL_LIST; do
        LOCAL_NAME=$(echo $LOCAL | sed 's/_.*//'); LOCAL_VER=$(echo $LOCAL | sed 's/^[^_]*_//g' | sed 's/[^0-9]*//g')
        if [ "$REMOTE_NAME" == "$LOCAL_NAME" ]; then INSTALLED=1; fi
        if [ "$REMOTE_NAME" == "$LOCAL_NAME" ] && [ ! "$REMOTE_VER" == "$LOCAL_VER" ]; then echo remote=$REMOTE ver=$REMOTE_VER local=$LOCAL ver=$LOCAL_VER; fi
    done
    if [ "$INSTALLED" == "0" ]; then echo "$REMOTE"; fi
done
IFS=$OFS

Comme quelqu'un a demandé comment le faire sans utiliser aapt. Il est également possible d'extraire des informations apk avec apktool et un peu de script. Cette méthode est plus lente et pas simple sous Android, mais fonctionnera sous Windows / Mac ou Linux tant que vous avez une configuration apktool fonctionnelle.

#!/bin/sh
APK=/path/to/your.apk
TMPDIR=/tmp/apktool
rm -f -R $TMPDIR
apktool d -q -f -s --force-manifest -o $TMPDIR $APK
APK=$(basename $APK)
VERSION=$(cat $TMPDIR/apktool.yml | grep "versionName" | sed -e "s/versionName: //")
LABEL=$(cat $TMPDIR/res/values/strings.xml | grep 'string name="title"' | sed -e 's/.*">//' -e 's/<.*//')
rm -f -R $TMPDIR
echo ${LABEL}_$(echo $V).apk

Pensez également à un dossier de dépôt sur votre serveur. Téléchargez des apks dessus et une tâche cron les renomme et les déplace vers votre dossier de mise à jour.

#!/bin/sh
# Drop Folder script for renaming APKs
# Read apk file from SRC folder and move it to TGT folder while changing filename to APKLABEL_APKVERSION.apk
# If an existing version of the APK exists in the target folder then script will remove it
# Define METHOD as "aapt" or "apktool" depending upon what is available on server 

# Variables
METHOD="aapt"
SRC="/home/user/public_html/dropfolders/apk"
TGT="/home/user/public_html/apk"
if [ -d "$SRC" ];then mkdir -p $SRC
if [ -d "$TGT" ]then mkdir -p $TGT

# Functions
get_apk_filename () {
    if [ "$1" = "" ]; then return 1; fi
    local A="$1"
    case $METHOD in
        "apktool")
            local D=/tmp/apktool
            rm -f -R $D
            apktool d -q -f -s --force-manifest -o $D $A
            local A=$(basename $A)
            local V=$(cat $D/apktool.yml | grep "versionName" | sed -e "s/versionName: //")
            local T=$(cat $D/res/values/strings.xml | grep 'string name="title"' | sed -e 's/.*">//' -e 's/<.*//')
            rm -f -R $D<commands>
            ;;
        "aapt")
            local A=$(aapt dump badging $A | grep -e "application-label:" -e "VersionName")
            local V=$(echo $A | sed -e "s/.*versionName='//" -e "s/' .*//")
            local T=$(echo $A | sed -e "s/.*application-label:'//" -e "s/'.*//")
            ;;
        esac
    echo ${T}_$(echo $V).apk
}

# Begin script
for APK in $(ls "$SRC"/*.apk); do
    APKNAME=$(get_apk_filename "$APK")
    rm -f $TGT/$(echo APKNAME | sed "s/_.*//")_*.apk
    mv "$APK" "$TGT"/$APKNAME
done

Pour le moment, cela peut être fait comme suit

$ANDROID_HOME/build-tools/28.0.3/aapt dump badging /<path to>/<app name>.apk

En général, ce sera:

$ANDROID_HOME/build-tools/<version_of_build_tools>/aapt dump badging /<path to>/<app name>.apk

Je peux maintenant récupérer avec succès la version d'un fichier APK à partir de ses données XML binaires.

C'est dans cette rubrique que j'ai obtenu la clé de ma réponse (j'ai également ajouté ma version du code de Ribo): Comment analyser le fichier AndroidManifest.xml dans un package .apk

De plus, voici le code d'analyse XML que j'ai écrit, spécifiquement pour récupérer la version:

Analyse XML

/**
 * Verifies at Conductor APK path if package version if newer 
 * 
 * @return True if package found is newer, false otherwise
 */
public static boolean checkIsNewVersion(String conductorApkPath) {

    boolean newVersionExists = false;

    // Decompress found APK's Manifest XML
    // Source: /programming/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689
    try {

        if ((new File(conductorApkPath).exists())) {

            JarFile jf = new JarFile(conductorApkPath);
            InputStream is = jf.getInputStream(jf.getEntry("AndroidManifest.xml"));
            byte[] xml = new byte[is.available()];
            int br = is.read(xml);

            //Tree tr = TrunkFactory.newTree();
            String xmlResult = SystemPackageTools.decompressXML(xml);
            //prt("XML\n"+tr.list());

            if (!xmlResult.isEmpty()) {

                InputStream in = new ByteArrayInputStream(xmlResult.getBytes());

                // Source: http://developer.android.com/training/basics/network-ops/xml.html
                XmlPullParser parser = Xml.newPullParser();
                parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);

                parser.setInput(in, null);
                parser.nextTag();

                String name = parser.getName();
                if (name.equalsIgnoreCase("Manifest")) {

                    String pakVersion = parser.getAttributeValue(null, "versionName");
                            //NOTE: This is specific to my project. Replace with whatever is relevant on your side to fetch your project's version
                    String curVersion = SharedData.getPlayerVersion();

                    int isNewer = SystemPackageTools.compareVersions(pakVersion, curVersion); 

                    newVersionExists = (isNewer == 1); 
                }

            }
        }

    } catch (Exception ex) {
        android.util.Log.e(TAG, "getIntents, ex: "+ex);
        ex.printStackTrace();
    }

    return newVersionExists;
}

Comparaison de version (vu comme SystemPackageTools.compareVersions dans l'extrait de code précédent) REMARQUE: Ce code est inspiré de la rubrique suivante: Moyen efficace de comparer les chaînes de version en Java

/**
 * Compare 2 version strings and tell if the first is higher, equal or lower
 * Source: /programming/6701948/efficient-way-to-compare-version-strings-in-java
 * 
 * @param ver1 Reference version
 * @param ver2 Comparison version
 * 
 * @return 1 if ver1 is higher, 0 if equal, -1 if ver1 is lower
 */
public static final int compareVersions(String ver1, String ver2) {

    String[] vals1 = ver1.split("\\.");
    String[] vals2 = ver2.split("\\.");
    int i=0;
    while(i<vals1.length&&i<vals2.length&&vals1[i].equals(vals2[i])) {
      i++;
    }

    if (i<vals1.length&&i<vals2.length) {
        int diff = Integer.valueOf(vals1[i]).compareTo(Integer.valueOf(vals2[i]));
        return diff<0?-1:diff==0?0:1;
    }

    return vals1.length<vals2.length?-1:vals1.length==vals2.length?0:1;
}

J'espère que ça aide.

Pour le scénario de mise à niveau, une approche alternative pourrait être de disposer d'un service Web fournissant le numéro de version actuelle et de le vérifier au lieu de télécharger l'intégralité de l'apk juste pour vérifier sa version. Cela économiserait de la bande passante, serait un peu plus performant (beaucoup plus rapide à télécharger qu'un apk si l'ensemble de l'apk n'est pas nécessaire la plupart du temps) et beaucoup plus simple à implémenter.

Dans la forme la plus simple, vous pourriez avoir un simple fichier texte sur votre serveur ... http://some-place.com/current-app-version.txt

À l'intérieur de ce fichier texte, il y a quelque chose comme

3.1.4

puis téléchargez ce fichier et vérifiez la version actuellement installée.

Construire une solution plus avancée à cela serait d'implémenter un service Web approprié et d'avoir un appel d'API au lancement qui pourrait renvoyer des json, c'est http://api.some-place.com/versionCheck-à- dire :

{
    "current_version": "3.1.4"
}

    EditText ET1 = (EditText) findViewById(R.id.editText1);

    PackageInfo pinfo;
    try {
        pinfo = getPackageManager().getPackageInfo(getPackageName(), 0);
        String versionName = pinfo.versionName;
        ET1.setText(versionName);
        //ET2.setText(versionNumber);
    } catch (NameNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }