Is there a non-app tool for batch backup of APK files? Just as the other times, an answer to my question shall not contemplate an app from either the Play Store, or any other source. What I'm after, is a tool capable to backup user apps, system apps or both those categories, when launched from within a working Android OS.

Backing up the apps' external data is not relevant. The only thing that counts, is the ability to batch backup the base.apk file, found in each /data/app/appName/ directory, in order for me to be able to reinstall it either in order to revert to a previous version, or to install it from scratch.

Lastly, I would prefer for the tool to be freely customizable (e.g. not compiled). Maybe something like a shell script?
This script is outdated and no longer supported. For the newest version, which requires Android 5+ and Python 3.5+, and supports Arcus theme variants and Substratum overlays, see my GitHub repository.



Here's my revamped script, now dubbed NEMRIS, which satisfies the question. As usual, it's freely editable by anyone, and sh-compliant as well, meaning that it can be ran from the Android shell.

Actually, the script depends upon the aapt utility, can discern if the utility is installed, is able to determine whether the backupDir and the appsToBackup variables are empty or not and, if they are, it sets default values instead of aborting.

Still, the date binary cannot determine your true time zone, so everyone should manually edit their TZ variable.

Once it has been ran for the first time, the tool is able to discern whether an APK has already been backed up or not, by making use of an array filled with MD5 checksums.

It also stores said array into a dictionary, called md5sums.txt, which is a plaintext file located into the APK backup directory. This feature is able to reduce the elapsed time of a good half, but it depends on a stat binary able to measure a file's exact size in bytes. If stat does not comply, the checksums will be computed each and every time, as in the previous version of the script. This is to ensure that NEMRIS will depend only upon aapt. Remember to manually wipe the md5sums.txt if you do some cleanup in the backup folder.

As a plus, the script now has a maxDictSize variable, which accepts an integer value. The inputted value will be interpreted as bytes. This can be customized, and serves to recompute the checksums dictionary if its size exceeds the maximum.

Finally, I patched it to support third-party apps whose names have forward slashes in them. No more weird errors, I guess.

I hope it may prove useful.

License: GNU General Public License, version 3 or later.



#!/system/bin/sh

# nemris - an Android app backup tool

# Copyright (C) 2016 Death Mask Salesman
# &lt;http://android.stackexchange.com/users/152843/death-mask-salesman&gt;

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License at &lt;http://www.gnu.org/licenses/&gt; for
# more details.

#This variable is used to calculate the total elapsed time
#DO NOT alter it, or the script won't be able to calculate it
SECONDS=0

#This variable is used to output the time when the script is launched
#Edit the plus/minus and the value after "UTC", to force date into displaying your correct time zone
timeAtStart="$(TZ=UTC-2 date +%H:%M:%S)"

#This variable stores the path where to backup your apps' APK files
#Edit it freely, but do not forget the quotes
backupDir=""

#This variable stores the path where the script is located
scriptDir="$(dirname "$(readlink -f "$0")")"

#This variable tells the script which apps to backup
#Supported values are:
# - "User": tells the script to backup only third-party apps
# - "System": tells the script to backup only system apps
# - "All": tells the script to backup both 3rd party and system apps
appsToBackup=""

#This variable contains the maximum size of the checksums dictionary, in bytes
#It is used to decide whether to flush the dictionary or not
typeset -i maxDictSize=20000

#This function outputs the time when the operations start. Purely cosmetic: can be disabled safely
#///Beginning of function "timeInfo"///
function timeInfo {
 echo "[ INFO ] Operations started at "$timeAtStart"."
}
#///End of function "timeInfo"///

#This function checks if the "aapt" and "stat" utilities are installed
#///Beginning of function "dependencyChecker"///
function dependencyChecker {
 echo "[ INFO ] Checking if aapt and stat are installed..."
 whence -v aapt &amp;&gt; /dev/null
 isAaptAbsent="$(echo $?)"

 whence -v stat &amp;&gt; /dev/null
 isStatAbsent="$(echo $?)"

 if [ "$isAaptAbsent" == "0" ]; then
  echo "[ INFO ] aapt has been found."
  unset isAaptAbsent
 else
  echo "[ FATAL ] aapt cannot be found. Aborting."
  exit
 fi

 if [ "$isStatAbsent" == "0" ]; then
  echo "[ INFO ] stat has been found."
  echo ""
  echo "[ INFO ] Checking if stat can measure exact file sizes..."

  stat -c %s "$scriptDir/nemris.sh" &amp;&gt; /dev/null
  if [ "$(echo $?)" == "0" ]; then
   echo "[ INFO ] Measurement successful."
   isStatUsable="1"
   unset isStatAbsent
  else
   echo "[ WARNING ] Measurement failed. stat will be ignored."
   isStatUsable="0"
   unset isStatAbsent
  fi
 else
  echo "[ WARNING ] stat cannot be found."
  isStatUsable="0"
  unset isStatAbsent
 fi
}
#///End of function "dependencyChecker"///

#This function verifies whether the values into "backupDir" and "appsToBackup" have anything inside or not
#In the case that the variables are empty, default values will be used, instead
#///Beginning of the function "variablesChecker"///
function variablesChecker {
 echo "[ INFO ] Checking if a backup path has already been specified..."
 if [ "$backupDir" == "$(cat /dev/null)" ]; then
  echo "[ WARNING ] A backup path has not been specified."
  echo "[ WARNING ] Setting the path to default (/sdcard/AppsBackup)."
  backupDir="/sdcard/AppsBackup"
 else
  echo "[ INFO ] Backup path has already been specified."
 fi
 echo ""

 echo "[ INFO ] Checking if the typology of apps to backup has already been chosen..."
 if [ "$appsToBackup" == "$(cat /dev/null)" ]; then
  echo "[ WARNING ] A typology of apps to backup has not been specified."
  echo "[ WARNING ] Setting the default typology (User)."
  appsToBackup="User"
 else
  echo "[ INFO ] A typology of apps has already been specified."
 fi
}
#///End of the function "variablesChecker"///

#This function emulates the case insensitivity for "appsToBackup", usually provided by brace expansion, but lacked by sh
#In the case that an unsupported value is found, a default value will be used instead
#///Beginning of the function "caseInsensitiveWorkaround"///
function caseInsensitiveWorkaround {
 systemArray="$(echo -n {s,S}{y,Y}{s,S}{t,T}{e,E}{m,M})"
 userArray="$(echo -n {u,U}{s,S}{e,E}{r,R})"
 allArray="$(echo -n {a,A}{l,L}{l,L})"

 case ${appsToBackup:0:1} in
  s|S)
   for i in $systemArray; do
    case "$appsToBackup" in
     $i)
      appsToBackup="System"
      ;;
    esac
   done
   ;;
  u|U)
   for i in $userArray; do
    case "$appsToBackup" in
     $i)
      appsToBackup="User"
      ;;
    esac
   done
   ;;
  a|A)
   for i in $allArray; do
    case "$appsToBackup" in
     $i)
      appsToBackup="All"
      ;;
    esac
   done
   ;;
  *)
   echo "[ WARNING ] \""$appsToBackup"\": invalid typology."
   echo "[ WARNING ] Setting the default typology (User)."
   appsToBackup="User"
   ;;
 esac

 case "$appsToBackup" in
  System|User|All)
   ;;
  *)
   echo "[ WARNING ] \""$appsToBackup"\": invalid typology."
   echo "[ WARNING ] Setting the default typology (User)."
   appsToBackup="User"
   ;;
 esac
}
#///End of the function "caseInsensitiveWorkaround"///

#This function checks if the backup directory already exists
#///Beginning of the function "backupDirCheck"///
function backupDirCheck {
 echo "[ INFO ] Checking if the backup directory already exists..."
 if [ -d "$backupDir" ]; then
  echo -n "[ INFO ] Backup directory already exists, "

  cd "$backupDir"
  #echo "[ INFO ] Checking if the directory is empty..."
  if [ "$(ls | grep "\.apk$" | head -n 1)" == "$(cat /dev/null)" ]; then
   echo "and does not have any APK file inside."
  else
   echo "and has at least an APK file inside."
   isDirectoryEmpty="0"
  fi
 else
  echo "[ INFO ] Backup directory does not exist. Creating it now."
  mkdir -p "$backupDir"
  cd "$backupDir"
 fi
}
#///End of the function "backupDirCheck"///

#This function compares the size of the checksums dictionary and flushes it if too big
#///Beginning of function "sizeComparer"///
function sizeComparer {
 echo "[ INFO ] Comparing the dictionary size to the max value..."

 typeset -i dictSize="$(stat -c %s "$backupDir/md5sums.txt")"
 if [ $dictSize -ge maxDictSize ]; then
  echo "[ INFO ] The dictionary size exceeds the maximum value. The checksums will be recomputed."
  dictTooBig="1"
  unset dictSize
 else
  echo "[ INFO ] The dictionary size does not exceed the maximum value."
 fi
}
#///End of function "sizeComparer"///

#This function generates a MD5 array, filled with the checksum of each APK file
#///Beginning of the function "checksumsGenerator"///
function checksumsGenerator {
 echo "[ INFO ] Generating file checksums..."
 apkList="$(printf "%s\n" * | grep "\.apk$")"
 for i in $apkList; do
  tempMd5=($(md5sum $i))
  md5Array="$tempMd5 $md5Array"
 done

 cat &lt;&lt; EOF &gt; "$backupDir/md5sums.txt"
md5Array="$md5Array"
EOF

 echo "[ INFO ] MD5 array generated."
}
#///End of the function "checksumsGenerator"///

#This function creates a list of the apps to backup, based on the content in "appsToBackup"
#///Beginning of the function "appListGenerator"///
function appListGenerator {
 case "$appsToBackup" in
  System)
   echo "[ INFO ] Retrieving system apps list..."
   appList="$(pm list packages -s)"
   ;;
  User)
   echo "[ INFO ] Retrieving third-party apps list..."
   appList="$(pm list packages -3)"
   ;;
  All)
   echo "[ INFO ] Retrieving apps list..."
   appList="$(pm list packages)"
   ;;
 esac

 echo "[ INFO ] Applications list retrieved."
}
#///End of the function "appListGenerator"///

#This function creates an array, filled with each app's full path
#///Beginning of the function "apkPathRetriever"///
function apkPathRetriever {
 echo "[ INFO ] Collecting the path of each app's APK..."
 for i in $appList; do
  apkPath="${i#p*:}"
  apkPath="$(pm path $apkPath)"
  apkPath="${apkPath#p*:}"
  pathArray="$apkPath $pathArray"
 done
 echo "[ INFO ] Paths collected."
}
#///End of the function "apkPathRetriever"///

#This function extracts the label or the package name for the APK supplied to it
#It extracts the app label for any third-party app, the package name for any system app
#///Beginning of the function "appNameRetriever"///
function appNameRetriever {
 case "$1" in
  /system/*)
   appName="${aaptOutput#*name=\'}"
   appName="${appName//\'*/}"
   displayedName="$appName"
   ;;
  /data/*|/mnt/asec/*)
   appName="${aaptOutput#*application-label:\'}"
   appName="${appName//app*/}"
   appName="${appName%\'*}"
   displayedName=$appName
   appName="${appName//\//}"
   appName="$(printf "%s" $appName)"
   ;;
 esac
}
#///End of the function "appNameRetriever"///

#This function retrieves the version number of the APK
#///Beginning of the function "appVersionRetriever"///
function appVersionRetriever {
 appVersion="${aaptOutput#*versionName=\'}"
 appVersion="${appVersion//platformBuildVersion*/}"
 appVersion="${appVersion%\'*}"
 appVersion="$(printf "%s" $appVersion)"
}
#///End of the function "appVersionRetriever"///

#This function compares the MD5 of the APK in question against any MD5 in the array
#If it finds a match, then the function exits and the APK isn't backed up
#///Beginning of the function "md5Compare"///
function md5Compare {
 alreadyBackedUp=0
 appMd5=($(md5sum "$1"))

 for c in $md5Array; do
  if [ "$alreadyBackedUp" == "0" ]; then
   if [ "$appMd5" == "$c" ]; then
    alreadyBackedUp=1;
   fi
  else
   break;
  fi
 done
}
#///End of the function "md5Compare"///

#This function decides whether to backup an app or not
#It calls both "appNameRetriever" and "appVersionRetriever" for renaming any copied "base.apk"
#It also decides whether to call "md5Compare" or not, in order to see if an app has already been backed up
#///Beginning of the function "apkBackup"///
function apkBackup {
 for i in $pathArray; do
  aaptOutput="$(aapt d badging "$i")"

  appNameRetriever "$i"
  appVersionRetriever

  if [ "$isDirectoryEmpty" == "0" ]; then
   md5Compare "$i"

   if [ "$alreadyBackedUp" == "0" ]; then
    echo -n "[ INFO ] Backing up "$displayedName"... "
    cp "$i" "$backupDir"/$appName"_"$appVersion.apk
    echo "done."
    md5Array="$appMd5 $md5Array"
   else
    echo "[ INFO ] "$displayedName" has already been backed up."
   fi
  else
   echo -n "[ INFO ] Backing up "$displayedName"... "
   cp "$i" "$backupDir"/$appName"_"$appVersion.apk
   echo "done."
  fi
 done

 if [ "$md5Array" != "$(cat /dev/null)" ]; then
  cat &lt;&lt; EOF &gt; "$backupDir/md5sums.txt"
md5Array="$md5Array"
EOF
 fi
}
#///End of the function "apkBackup"///

#This is the core of the tool
echo "**************************"
echo " NEMRIS - App backup tool "
echo "  by Death Mask Salesman  "
echo "**************************"

timeInfo
echo ""

dependencyChecker
echo ""

variablesChecker
echo ""

caseInsensitiveWorkaround
echo ""

backupDirCheck
echo ""

#This section checks whether to analyze the dictionary size
#It also decides whether to compute the checksums
if [ "$isDirectoryEmpty" == "0" ]; then
 if [ -e "$backupDir/md5sums.txt" ]; then
  if [ "$isStatUsable" == "1" ]; then
   sizeComparer
   echo ""
  else
   dictTooBig="1"
  fi

  if [ "$dictTooBig" == "1" ]; then
   checksumsGenerator
   echo ""
  else
   source "$backupDir/md5sums.txt"
  fi  
 else
  echo "[ INFO ] Checksums not calculated yet."
  checksumsGenerator
  echo ""
 fi
fi

appListGenerator
echo ""

apkPathRetriever
echo ""

apkBackup
echo ""

echo "[ INFO ] Operations took "$(((SECONDS/60)/60))" hours, "$(((SECONDS/60)%60))" minutes and "$((SECONDS%60))" seconds."
echo "[ INFO ] All done!"