2

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?

5

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
# <http://android.stackexchange.com/users/152843/death-mask-salesman>

# 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 <http://www.gnu.org/licenses/> 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 &> /dev/null
 isAaptAbsent="$(echo $?)"

 whence -v stat &> /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" &> /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 << EOF > "$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 << EOF > "$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!"
  • 1
    If you want more functionality, take a look at my script: Adebar :) Just requires Bash and ADB, but doesn't run directly on the device (needs a computer with Linux or Cygwin) and a.o. creates scripts for adb backup – so no plain .apk files either (though that could be added, root given). – Izzy Apr 26 '16 at 21:32
  • +1. Death Mask Salesman, thank you very much for writing and releasing this script! I wonder if you could please release the script under some software license? (This whole website is CC-BY-SA 3.0, but that isn't a very good software license.) If you tell me what country you live in, maybe I can provide you with more advice on how to easily choose and apply a license. – unforgettableid Jul 13 '16 at 18:37
  • @unforgettableid Glad that it turned out to be useful. As per your suggestion, I decided to license the script, with the GNU GPLv3, in order to ensure that anyone will be able to use and modify it to suit their needs. – Death Mask Salesman Jul 13 '16 at 19:04
  • @DeathMaskSalesman: Thank you very much! "GPLv2 or later" might have been even better, for license-compatibility reasons, but "GPLv3 or later" is excellent too. – unforgettableid Jul 13 '16 at 19:19
1

This is a particular, improved version of the standard Nemris tool. It constitutes a separate answer because, while it provides a dramatic speed improvement, it's mostly untested (it works for certain under CM12.1 and CM13).


License

This tool is licensed under the WTFPL license. In other words, do what you want with it. Reuse its components, sublicense it... and quote me as the original author, if you wish. I take no responsibilities, though.


Differences from the old Nemris

  • The verbosity of the tool has been reduced.
  • stat is no longer necessary.
  • The backup speed has been greatly improved: a delta backup takes around 25 seconds, rather than one minute.
  • Fixed the buggy backup of system apps by ignoring aapt.
  • Added support for backup of disabled apps.
  • Two optional command line arguments have been added; the usage is below.

Default backup directory

To specify a custom backup directory, manually edit line 17. If you leave it blank, the script will default to /sdcard/NemrisBackup.


Usage

Nemris can be either launched without arguments, or with two optional arguments. Usage:

nemris.sh [app_typology] [reset]

. The first argument can be User, System, Disabled or All, or even be left blank. If the supplied argument is unrecognized or null, the tool defaults to User. Case insensitivity is supported.

The second argument may only be reset, and may be specified only if the first argument has been specified as well. If you do so, the tool will delete and recreate its configuration files, which are located in the same place as the script.


#!/system/bin/sh

# A bunch of variables and a function that facilitate the script's workings
# Do not alter them unless you know what you're doing
SECONDS=0
app_typology="$1"
null="$(cat /dev/null)"
script_location="$(dirname "$(readlink -f "$0")")"

function var_to_file {
 echo "$1=\"$2\"" >> "$script_location/nemris_config.txt"
}

####################

# This variable is needed to define the backup location
backup_location=""

####################

# This function cleans up the files generated in a previous execution
function settings_md5_files_delete {
 echo -ne "[ INFO ] Deleting Nemris configuration and MD5 dictionary..."

 if [ -e "$script_location/nemris_config.txt" ]; then
  if [ -e "$script_location/md5_dictionary.txt" ]; then
   rm "$script_location/nemris_config.txt" "$script_location/md5_dictionary.txt"
  else
   rm "$script_location/nemris_config.txt"
  fi
 else
  if [ -e "$script_location/md5_dictionary.txt" ]; then
   rm "$script_location/md5_dictionary.txt"
  else
   echo -ne " no files to remove..."
  fi
 fi

 echo " done. The files will be regenerated."
}

# This function checks if a settings file has been generated from a previous execution and loads its data
function settings_file_check {
 echo -ne "[ INFO ] Checking for Nemris configuration file..."

 if [ -e "$script_location/nemris_config.txt" ]; then
  echo " found."

  if [ "$backup_location" == "$null" ]; then
   source "$script_location/nemris_config.txt"
  else
   temp="$backup_location"
   source "$script_location/nemris_config.txt"
   backup_location="$temp"

   unset temp
  fi
 else
  echo " not found. The configuration will be regenerated."

  touch "$script_location/nemris_config.txt"
 fi
}

# This function reads the list of the packages and generates a special dictionary
# This is the reason of the time gain between the legacy Nemris and this version
function packages_file_write {
 echo -ne "[ INFO ] Generating refined packages list..."

 if [ -e "$script_location/packages.txt" ]; then
  echo -n "$null" > "$script_location/packages.txt"
 fi

 cat "/data/system/packages.xml" | grep "package name" > "$script_location/packages.txt"

 IFS=$'\n'

 packages="$(cat "$script_location/packages.txt")"
 echo -n "$null" > "$script_location/packages.txt"

 for i in $packages; do
  package_name="${i//*package name=\"/}"
  package_name="${package_name//\"*/}"

  package_path="${i//*codePath=\"/}"
  package_path="${package_path//\"*/}"

  if [ "$(echo -ne "$package_path" | grep "\.apk$")" == "$null" ]; then
   package_path="$package_path/$(ls "$package_path" | grep "\.apk$")"
  fi

  echo "$package_name:$package_path" >> "$script_location/packages.txt"
 done

 unset IFS package package_name package_path

 echo " done."
}

# This function checks if aapt is installed
function aapt_check {
 echo -ne "[ INFO ] Checking for aapt..."

 whence -v aapt &> /dev/null
 is_aapt_missing="$(echo $?)"

 var_to_file "is_aapt_missing" "$is_aapt_missing"

 echo " done."
}

# This function sets the backup location and the app typology to backup to default
function variables_default {
 case $1 in
  0)
   echo -ne "[ INFO ] Setting backup directory and app typology to default..."

   backup_location="/sdcard/NemrisBackup"
   app_typology="User"

   var_to_file "backup_location" "$backup_location"

   echo " done."
   ;;
  1)
   echo -ne "[ INFO ] Setting backup location to default..."

   backup_location="/sdcard/NemrisBackup"

   var_to_file "backup_location" "$backup_location"

   echo " done."
   ;;
  2)
   echo -ne "[ INFO ] Setting app typology to default..."

   app_typology="User"

   echo " done."
   ;;
 esac
}

# This function ensures case insensitivity and saves a headache to the user
function app_typology_sanitize {
 case ${app_typology:0:1} in
  s|S)
   if [ "$system_permutations" == "$null" ]; then
    permutations_already_calculated=0
    system_permutations="$(echo -n {s,S}{y,Y}{s,S}{t,T}{e,E}{m,M})"
   fi

   for i in $system_permutations; do
    if [ "$app_typology" == "$i" ]; then
     app_typology="System"
     break
    fi
   done

   if [ "$permutations_already_calculated" == "0" ]; then
    var_to_file "system_permutations" "$system_permutations"
   fi
   ;;
  u|U)
   if [ "$user_permutations" == "$null" ]; then
    permutations_already_calculated=0
    user_permutations="$(echo -n {u,U}{s,S}{e,E}{r,R})"
   fi

   for i in $user_permutations; do
    if [ "$app_typology" == "$i" ]; then
     app_typology="User"
     break
    fi
   done

   if [ "$permutations_already_calculated" == "0" ]; then
    var_to_file "user_permutations" "$user_permutations"
   fi
   ;;
  d|D)
   if [ "$disabled_permutations" == "$null" ]; then
    permutations_already_calculated=0
    disabled_permutations="$(echo -n {d,D}{i,I}{s,S}{a,A}{b,B}{l,L}{e,E}{d,D})"
   fi

   for i in $disabled_permutations; do
    if [ "$app_typology" == "$i" ]; then
     app_typology="Disabled"
     break
    fi
   done

   if [ "$permutations_already_calculated" == "0" ]; then
    var_to_file "disabled_permutations" "$disabled_permutations"
   fi
   ;;
  a|A)
   if [ "$all_permutations" == "$null" ]; then
    permutations_already_calculated=0
    all_permutations="$(echo -n {a,A}{l,L}{l,L})"
   fi

   for i in $all_permutations; do
    if [ "$app_typology" == "$i" ]; then
     app_typology="All"
     break
    fi
   done

   if [ "$permutations_already_calculated" == "0" ]; then
    var_to_file "all_permutations" "$all_permutations"
   fi
   ;;
  System|User|Disabled|All)
   ;;
  *)
   echo -ne "[ WARN ] \"$app_typology\": invalid value. Setting to default (User)..."

   app_typology="User"

   echo " done."
   ;;
 esac

 case $app_typology in
  System|User|Disabled|All)
   ;;
  *)
   echo -ne "[ WARN ] \"$app_typology\": invalid value. Setting to default (User)..."

   app_typology="User"

   echo " done."
   ;;
 esac
}

# This function checks if the backup directory contains any APK
function backup_location_check {
 if [ -d "$backup_location" ]; then
  if [ "$(ls "$backup_location" | grep "\.apk$")" == "$null" ]; then
   backup_directory_is_empty=1
  else
   backup_directory_is_empty=0
  fi
 else
  echo -ne "[ INFO ] Creating backup directory..."

  mkdir -p "$backup_location"

  echo " done."
 fi

 cd "$backup_location"
}

# This function generates a MD5 checksums dictionary
# This shortens down the operations time in any execution of the script
function md5_dict_generate {
 echo -ne "[ INFO ] Generating MD5 checksums..."

 apk_list="$(printf "%s\n" * | grep "\.apk$")"

 for i in $apk_list; do
  temp=($(md5sum "$i"))
  md5_array="$temp $md5_array"
 done

 echo -n "md5_array=\""$md5_array"\"" > "$script_location/md5_dictionary.txt"

 echo " done."
}

# This function retrieves the list of installed apps
function apps_list_retrieve {
 case $app_typology in
  System)
   echo -ne "[ INFO ] Retrieving system apps list..."

   for i in $(pm list packages -s); do
    pkg="${i//p*:/}"
    pkg="${pkg//./\\.}"
    apps_list="$apps_list $pkg"
   done

   echo " done."
   ;;
  User)
   echo -ne "[ INFO ] Retrieving third-party apps list..."

   for i in $(pm list packages -3); do
    pkg="${i//p*:/}"
    pkg="${pkg//./\\.}"
    apps_list="$apps_list $pkg"
   done

   echo " done."
   ;;
  Disabled)
   echo -ne "[ INFO ] Retrieving disabled apps list..."

   for i in $(pm list packages -d); do
    pkg="${i//p*:/}"
    pkg="${pkg//./\\.}"
    apps_list="$apps_list $pkg"
   done

   echo " done."
   ;;
  All)
   echo -ne "[ INFO ] Retrieving apps list..."

   for i in $(pm list packages); do
    pkg="${i//p*:/}"
    pkg="${pkg//./\\.}"
    apps_list="$apps_list $pkg"
   done

   echo " done."
   ;;
 esac
}

# This function retrieves the APKs paths via their package name (from the dictionary)
# Actually, this is the second part of the magic
function apks_paths_retrieve {
 echo -ne "[ INFO ] Collecting the path of each app's APK..."

 for i in $apps_list; do
  row="$(cat "$script_location/packages.txt" | grep "$i:")"
  paths_list="$paths_list ${row//*:/}"
 done

 echo " done."
}

# This function retrieves the app name
# If an app has no name, it falls back to the package name
function app_name_retrieve {
 app_name="$(echo -ne "$aapt_output" | grep "application-label:\'")"

 if [ "$app_name" != "$null" ]; then
  app_name="${app_name//application-label:\'/}"
  app_name="${app_name%\'*}"
  displayed_name="$app_name"
  app_name="${app_name//\//}"
  app_name="$(printf "%s" $app_name)"
 else
  app_name="$(echo -ne "$aapt_output" | grep "package: name.")"
  app_name="${app_name//package: name=\'/}"
  app_name="${app_name//\'*/}"
  displayed_name="$app_name"
 fi
}

# This function retrieves the app version
# If an app has no version (weird, but that happens) it defaults to "None"
function app_version_retrieve {
 app_version="${aapt_output#*versionName=\'}"
 app_version="${app_version//platformBuildVersion*/}"
 app_version="${app_version%\'*}"
 app_version="$(printf "%s" $app_version)"

 if [ "$app_version" == "$null" ]; then
  app_version="None"
 fi
}

# This function sets the app name to the name of the APK file
# It's used when the app to be backed up is a system app, which may make aapt go crazy
function system_app_name_set {
 app_name="$(basename $1)"
 app_name="${app_name%\.apk}"
 displayed_name="$app_name"
}

# This function checks if the checksum of any app figures in the already backed up apps
# This way, any app is backed up exactly once, and Nemris cannot be fooled by file names
function md5_compare {
 already_backed_up=0
 app_md5=($(md5sum "$1"))

 for c in $md5_array; do
  if [ "$already_backed_up" == "0" ]; then
   if [ "$app_md5" == "$c" ]; then
    already_backed_up=1
   fi
  else
   break
  fi
 done
}

# This function backs up the APK files, and calls the appropriate functions to handle both system and third-party apps
function apk_backup {
 for i in $paths_list; do
  case $i in
   /system/*)
    system_app_name_set $i
    ;;
   /data/app/*|/mnt/asec/*)
    aapt_output="$(aapt d badging "$i")"

    app_name_retrieve
    app_version_retrieve
    ;;
  esac

  if [ "$backup_directory_is_empty" == "0" ]; then
   md5_compare "$i"

   if [ "$already_backed_up" == "0" ]; then
    echo -ne "[ INFO ] Backing up "$displayed_name"..."

    case $i in
     /system/*)
      cp "$i" "$backup_location"/$app_name.apk
      ;;
     /data/app/*|/mnt/asec/*)
      cp "$i" "$backup_location"/$app_name"_"$app_version.apk
      ;;
    esac

    md5_array="$app_md5 $md5_array"

    echo " done."
   else
    echo "[ INFO ] "$displayed_name" has already been backed up."
   fi
  else
   echo -ne "[ INFO ] Backing up "$displayed_name"..."

   case $i in
    /system/*)
     cp "$i" "$backup_location"/$app_name.apk
     ;;
    /data/app/*|/mnt/asec/*)
     cp "$i" "$backup_location"/$app_name"_"$app_version.apk
     ;;
   esac

   echo " done."
  fi
 done

 if [ "$md5_array" != "$null" ]; then
  echo -ne "md5_array=\""$md5_array"\"" > "$script_location/md5_dictionary.txt"
 fi
}

# This function informs about the time that has been required by all of the operations
function goodbye {
 echo "[ INFO ] Operations took "$(((SECONDS/60)/60))" hours, "$(((SECONDS/60)%60))" minutes and "$((SECONDS%60))" seconds."
 echo "[ INFO ] All done!"
}

####################

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

# Logic that handles the optional second argument that may be supplied by an user
# Only the "reset" argument is detected
if [ "$2" == "reset" ]; then
 settings_md5_files_delete
else
 settings_file_check
fi

packages_file_write

if [ "$is_aapt_missing" == "$null" ]; then
 aapt_check
fi

# Logic that aborts the execution if aapt is not present
if [ "$is_aapt_missing" == "1" ]; then
 echo "[ FATAL ] aapt is not installed: aborting."
 exit
fi

# Logic that decides whether variables to check
if [ "$backup_location" == "$null" ]; then
 if [ "$app_typology" == "$null" ]; then
  variables_default 0
 else
  variables_default 1
  app_typology_sanitize
 fi
else
 if [ "$app_typology" == "$null" ]; then
  variables_default 2
  else
   app_typology_sanitize
 fi
fi

backup_location_check

# Logic that checks whether to compute the checksums of the already backed up apps
if [ "$backup_directory_is_empty" == "0" ]; then
 if [ ! -e "$script_location/md5_dictionary.txt" ]; then
  md5_dict_generate
 else
  source "$script_location/md5_dictionary.txt"
 fi
fi

apps_list_retrieve

apks_paths_retrieve

echo ""

apk_backup

echo ""

goodbye

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.