NanoDroid/CommonInstaller

#!/sbin/sh

VERSION=22.4.20190811
NANODROID_UPGRADE=0
INSTALL_SUCCESS=TRUE
NANODROID_LIST=/data/adb/NanoDroid_FileList
STORAGE=/data/media/0

print_google_apps()
{
cat <<EOF
AMAPNetworkLocation
BaiduNetworkLocation
BlankStore
ConfigUpdater
GCS
GmsCoreSetupPrebuilt
GmsCore_update
GoogleFeedback
GoogleLoginService
GoogleOneTimeInitializer
GoogleServicesFramework
GoogleConnectivityServices
GoogleTTS
LegacyNetworkLocation
MarketUpdater
MarkupGoogle
NetworkLocation
Phonesky
PlayGames
PlayStore
PrebuiltGmsCore
PrebuiltGmsCorePi
PrebuiltGmsCorePix
UnifiedNlp
Velvet
Vending
WhisperPush
EOF
}

print_google_data ()
{
cat <<EOF
com.amap.android.location
com.baidu.location
com.google.android.location
org.microg.nlp
org.microg.unifiednlp
EOF
}

print_google_data_dirty ()
{
cat <<EOF
com.android.vending
com.google.android.gms
com.google.android.gsf
com.google.android.gsf.login
com.google.android.feedback
com.mgoogle.android.gms
EOF
}

##########################################################################################
# Misc. Functions
##########################################################################################

check_space () {
	space_required=524288
	space_available=$(df /dev 2>/dev/null | awk '/tmpfs/{print $4}')

	echo "  required space : ${space_required}"
	echo "  available space: ${space_available}"

	if [ ${space_available} -lt ${space_required} ]; then
		error "Less than 512 MB free space availabe from TWRP!"
	fi
}

detect_bootmode () {
	[ -z ${BOOTMODE} ] && BOOTMODE=false
	${BOOTMODE} || ps | grep zygote | grep -qv grep && BOOTMODE=true
	${BOOTMODE} || ps -A 2>/dev/null | grep zygote | grep -qv grep && BOOTMODE=true

	${BOOTMODE} && error "${MODID} must be flashed from TWRP!"
}

ui_print() {
	if ${BOOTMODE}; then
		echo "${@}"
	else 
		echo -n -e "ui_print ${@}\n" >> /proc/self/fd/${OUTFD}
		echo -n -e "ui_print\n" >> /proc/self/fd/${OUTFD}
	fi
}

show_progress() {
	echo "progress ${1} ${2}" >> /proc/self/fd/${OUTFD}
}

set_progress() {
	echo "set_progress ${1}" >> /proc/self/fd/${OUTFD}
}

grep_prop() {
	[ -f /vendor/build.prop ] && \
		FILES="/system/build.prop /vendor/build.prop" || \
		FILES="/system/build.prop"

	sed -n "s/^${1}=//p" ${FILES} | head -n 1
}

grep_cmdline() {
	local REGEX="s/^${1}=//p"
	sed -E 's/ +/\n/g' /proc/cmdline | \
		sed -n "${REGEX}" 2>/dev/null
}

is_mounted() {
	grep -q "$(readlink -f ${1})" /proc/mounts 2>/dev/null
	return $?
}

set_perm () {
	chown ${2}:${3} ${1} || error "failed change owner for ${1}"
	chmod ${4} ${1} || error "failed to change mode for ${1}"

	if [ ! -z "${5}" ]; then
		chcon ${5} ${1} 2>/dev/null
	else	chcon 'u:object_r:system_file:s0' ${1} 2>/dev/null
	fi
}

set_perm_recursive() {
	find ${1} -type d 2>/dev/null | while read dir; do
		set_perm ${dir} ${2} ${3} ${4} ${6}
	done
	find ${1} -type f 2>/dev/null | while read file; do
		set_perm ${file} ${2} ${3} ${5} ${6}
	done
}

set_perm_data () {
	if [ "${1}" = "-r" ]; then
		echo "    perm: data [recursive] {${2}}"
		set_perm_recursive ${2} 0 0 0755 0644
	else
		echo "    perm: data [single] {${1}}"
		set_perm ${1} 0 0 0644
	fi
}

set_perm_bin () {
	if [ "${1}" = "-r" ]; then
		echo "    perm: exec [recursive] {${2}}"
		set_perm_recursive ${2} 0 0 0755 0755
	else
		echo "    perm: exec [single] {${1}}"
		set_perm ${1} 0 0 0755
	fi
}

installinfo_add () {
	if [ "${MODE}" = "SYSTEM" ]; then
		for file in ${@}; do
			echo ${file} >> ${NANODROID_LIST}
		done
	fi
}

detect_outfd () {
	if [ -z $OUTFD ] || readlink /proc/$$/fd/$OUTFD | grep -q /tmp; then
		# We will have to manually find out OUTFD
		for FD in `ls /proc/$$/fd`; do
			if readlink /proc/$$/fd/$FD | grep -q pipe; then
				if ps | grep -v grep | grep -q " 3 $FD "; then
					OUTFD=$FD
					break
				fi
			fi
		done
	fi
}

show_banner () {
	ui_print " "
	ui_print "*****************************"
	ui_print " NanoDroid                   "
	case ${MODID} in
		NanoDroid )
			ui_print " > Full package              "
		;;
		NanoDroid_microG )
			ui_print " > microG package            "
		;;
		NanoDroid_FDroid )
			ui_print " > F-Droid package           "
		;;
		NanoDroid_BromiteWebView )
			ui_print " > Bromite WebView package   "
		;;
		NanoDroid_OsmAnd )
			ui_print " > OsmAnd package            "
		;;
	esac
	ui_print " ${VERSION}                  "
	ui_print "*****************************"
	ui_print " "
}

error () {
	ui_print " !!"
	ui_print "${@}"
	ui_print " !!"

	if is_mounted /data; then
		[ "${MODE}" = "MAGISK" ] && rm -rf "${MODPATH}"

		recovery_cleanup

		INSTALL_SUCCESS=FALSE
		nanodroid_storelogs
	fi

	exit 1
}

# taken from Magisk, with minor modifications for NanoDroid
mount_partitions () {
	SLOT=$(grep_cmdline androidboot.slot_suffix)
	if [ -z ${SLOT} ]; then
		SLOT=_$(grep_cmdline androidboot.slot)
		[ "${SLOT}" = "_" ] && SLOT=
	fi

	DEVICE_AB=FALSE
	VENDOR_COMPAT=FALSE
	SYSTEM_AS_ROOT=FALSE

	is_mounted /data || mount /data || error "failed to mount /data!"

	mount -o bind /dev/urandom /dev/random
	! is_mounted /system && mount -o rw /system || mount -o rw,remount /system

	if [ ! -f /system/build.prop ]; then
		DEVICE_AB=TRUE
		SYSTEMBLOCK=$(find /dev/block -iname system${SLOT} | head -n 1)
		mount -o rw ${SYSTEMBLOCK} /system
	fi

	if [ -f /system/init.rc ]; then
		SYSTEM_AS_ROOT=TRUE
		[ -L /system_root ] && rm -f /system_root
		mkdir -p /system_root 2>/dev/null
		mount --move /system /system_root
		mount -o bind /system_root/system /system
	else
		grep ' / ' /proc/mounts | grep -qv 'rootfs' || \
			grep -q ' /system_root ' /proc/mounts \
			&& SYSTEM_AS_ROOT=TRUE || SYSTEM_ROOT=FALSE
	fi

	[ ! -f /system/build.prop ] && error "failed to mount /system (unsupported A/B device?)"

	if [ -L /system/vendor ]; then
		! is_mounted /vendor && mount /vendor
		if ! is_mounted /vendor; then
			VENDORBLOCK=$(find /dev/block -iname vendor${SLOT} | head -n 1)
			mount -o ro ${VENDORBLOCK} /vendor
		fi
	elif [ -d /system/vendor ]; then
		### XXX work-around required for some ROMs
		VENDOR_COMPAT=TRUE
		echo " xxx compat /vendor link created!"
		ln -sf /system/vendor /vendor >/dev/null
	fi

	mount | awk '{print $1 " on " $3 " params: " $6}'
}

detect_mode () {
	case "${nanodroid_forcesystem}" in
		1 )
			MODE_DETECT=forced
			MODE=SYSTEM
		;;

		0 | *)
			MODE=SYSTEM
			MODE_DETECT=detected

			for magisk in /data/adb/magisk/magisk /data/magisk/magisk \
				/data/.magisk/magisk /data/adb/modules; do
				if [ -e ${magisk} ]; then
					MODE=MAGISK
					break
				fi
			done

			if [ -f "${NANODROID_LIST}" ]; then
				MODE=SYSTEM
				NANODROID_UPGRADE=1
			fi
		;;
	esac

	ui_print " > Mode   | ${MODE}            | ${MODE_DETECT}"
	ui_print " "

	case ${MODE} in
		SYSTEM )
			recovery_actions
			unset MODPATH
		;;

		MAGISK )
			magisk_install_setup

			case ${MODID} in
				NanoDroid | NanoDroid_microG )
					magisk_install_preinst
				;;
			esac

			rm -rf "${MODPATH}"
		;;
	esac

	if [ "${nanodroid_fonts}" -eq 1 ]; then
		if test -h ${MODPATH}/system/fonts/Roboto-Regular.ttf; then
			CUSTOM_FONT="$(basename $(readlink ${MODPATH}/system/fonts/Roboto-Regular.ttf) .ttf)"
			ui_print " << Detected NanoDroid-Font (${CUSTOM_FONT})"
		fi
	fi

	[ "${ROM_NO_XBIN}" -eq 1 ] && \
		NANODROID_BINDIR="${MODPATH}/system/bin" || \
		NANODROID_BINDIR="${MODPATH}/system/xbin"
}

detect_migrate_microg () {
	GMSCORE_PATH=$(find /data/app -type d -name 'com.google.android.gms-*' 2>/dev/null)

	if [ ! -z ${GMSCORE_PATH} ]; then
		if ${UNZIP} -l "${GMSCORE_PATH}/base.apk" | grep META-INF/NANOLX.RSA 2>/dev/null; then
			echo "    + Removing NanoDroid microG GmsCore in favor of Official microG GmsCore"
			rm -rf "${GMSCORE_PATH}"

			echo "    + Resetting GCM/FCM connection of all apps to allow re-registration"
			find /data/data/*/shared_prefs -name com.google.android.gms.*.xml -delete
		fi
	fi

	DROIDGUARD_PATH=$(find /data/app -type d -name 'org.microg.gms.droidguard-*' 2>/dev/null)

	if [ ! -z ${DROIDGUARD_PATH} ]; then
		if ${UNZIP} -l "${DROIDGUARD_PATH}/base.apk" | grep META-INF/NANOLX.RSA 2>/dev/null; then
			echo "    + Removing NanoDroid DroidGuard in favor of Official DroidGuard"
			rm -rf "${DROIDGUARD_PATH}"
		fi
	fi
}

unpack_zip () {
	TMPDIR=/dev/tmp
	TMP_LIBDIR=${TMPDIR}/nanodroid-lib
	INSTALLER=${TMPDIR}/install

	rm -rf ${INSTALLER}
	mkdir -p ${INSTALLER} || error "failed to prepare environment!"

	ui_print " > prepare installation"
	unzip -oq "${ZIP}" -d "${INSTALLER}" || \
		error "failed to prepare environment!"

	rm -rf ${TMPDIR}/framework-res
	rm -f ${TMPDIR}/*.xml
	rm -f ${TMPDIR}/*.list
}

nanodroid_finalize () {
	case ${MODID} in
		NanoDroid | NanoDroid_microG )
			if [ "${nanodroid_overlay}" -eq 1 ]; then
				ui_print " << with /system applications overlays"
				${NANODROID_BINDIR}/nanodroid-overlay --create
			else
				ui_print " << without /system applications overlays"
			fi
		;;
	esac

	if [ "${MODE}" = "MAGISK" ]; then
		magisk_install_finish
	else
		install_addond
		recovery_cleanup

		sort ${NANODROID_LIST} | uniq > /tmp/nanodroid-list
		mv /tmp/nanodroid-list ${NANODROID_LIST}
	fi

	ui_print " "
	ui_print " Thanks for using NanoDroid "
	ui_print " "

	sync
	nanodroid_storelogs

	rm -rf ${INSTALLER}

	umount -l /system_root 2>/dev/null
	umount -l /system 2>/dev/null
	umount -l /vendor 2>/dev/null
	umount -l /dev/random 2>/dev/null
}

##########################################################################################
# Architecture detection
##########################################################################################

detect_arch () {
	SDK_VERSION=$(grep_prop ro.build.version.sdk)

	ABI=$(grep_prop ro.product.cpu.abi | cut -c-3)
	ABI2=$(grep_prop ro.product.cpu.abi2 | cut -c-3)
	ABILONG=$(grep_prop ro.product.cpu.abi)

	ARCH=arm

	[ "$ABI" = "x86" ] && ARCH=x86
	[ "$ABI2" = "x86" ] && ARCH=x86
	[ "$ABILONG" = "arm64-v8a" ] && ARCH=arm64
	[ "$ABILONG" = "x86_64" ] && ARCH=x86_64

	case ${ARCH} in
		arm )		BIN_ARCH="arm"
				LIB_ARCHES="armeabi-v7a armeabi"
				SWIPE_LIBDIR=lib ;;
		arm64 )		BIN_ARCH="arm"
				LIB_ARCHES="arm64-v8a armeabi-v7a armeabi"
				SWIPE_LIBDIR=lib64 ;;
		x86 )		BIN_ARCH="x86"
				LIB_ARCHES="x86 armeabi-v7a armeabi"
				SWIPE_LIBDIR=lib ;;
		x86_64 )	BIN_ARCH="x86"
				LIB_ARCHES="x86_64 x86 armeabi-v7a armeabi"
				SWIPE_LIBDIR=lib64 ;;
	esac

	UNZIP="${INSTALLER}/unzip.${BIN_ARCH}"
	chmod +x "${UNZIP}"

	AAPT="${INSTALLER}/aapt.${BIN_ARCH}"
	chmod +x "${AAPT}"

	case ${SDK_VERSION} in
		19 )		GSYNC_VER=K	;;
		21 | 22 )	GSYNC_VER=L	;;
		23 )		GSYNC_VER=M	;;
		24 | 25 )	GSYNC_VER=N	;;
		26 | 27 )	GSYNC_VER=O	;;
		28 )		GSYNC_VER=P	;;
		* )	GSYNC_UNSUPPORTED=1	;;
	esac


	case ${ARCH} in
		arm )
			case ${SDK_VERSION} in
				19 | 21 | 22 | 23 | 27 | 28 )
					LIBJNI_IME=libjni_latinimegoogle.so_${SDK_VERSION}
				;;
				24 | 25 | 26 )
					LIBJNI_IME=libjni_latinimegoogle.so_23
				;;
				* )
					SWIPE_UNSUPPORTED=1
				;;
			esac
		;;

		arm64 )
			case ${SDK_VERSION} in
				21 | 22 | 23 | 27 | 28 )
					LIBJNI_IME=libjni_latinimegoogle.so_${SDK_VERSION}
				;;
				24 | 25 | 26 )
					LIBJNI_IME=libjni_latinimegoogle.so_23
				;;
				* )
					SWIPE_UNSUPPORTED=1
				;;
			esac
		;;

		x86 | x86_64 )
			case ${SDK_VERSION} in
				19 | 21 | 22 )
					SWIPE_UNSUPPORTED=1
				;;
				23 | 24 | 25 | 26 | 27 | 28 )
					LIBJNI_IME=libjni_latinimegoogle.so
				;;
				* )
					SWIPE_UNSUPPORTED=1
				;;
			esac
		;;
	esac

	if [[ "${SDK_VERSION}" -lt 21 ]]; then
		UNFOLD_APP_DIR=1
	else	UNFOLD_APP_DIR=0
	fi

	if [[ "${SDK_VERSION}" -lt 19 ]]; then
		ui_print " "
		ui_print " ++ Installing on pre-KitKat ROM, full"
		ui_print " ++ compatibility is not garantueed!"
		ui_print " "
	fi

	if [ ! -d /system/xbin ]; then
		ROM_NO_XBIN=1
		echo " ++ ROM has no /system/xbin, using /system/bin instead"
	else	ROM_NO_XBIN=0
	fi

	[ ! -d /data/adb ] && mkdir /data/adb
}

setup_busybox () {
	OLD_PATH=${PATH}

	mkdir -p ${INSTALLER}/busybox
	ln -s ${INSTALLER}/busybox.${BIN_ARCH} ${INSTALLER}/busybox/busybox

	chmod 0755 ${INSTALLER}/busybox.${BIN_ARCH}
	${INSTALLER}/busybox.${BIN_ARCH} --install -s ${INSTALLER}/busybox/

	chmod 0755 ${INSTALLER}/sqlite3.${BIN_ARCH}

	# XXX Magisk recovery_actions() compat
	export BBDIR="${INSTALLER}/busybox"

	export PATH="${INSTALLER}/busybox:${PATH}"
}

# Taken from Magisk, used for System Mode installation
recovery_actions () {
	mv /sbin /sbin_tmp
	OLD_LD_LIB=$LD_LIBRARY_PATH
	OLD_LD_PRE=$LD_PRELOAD
	unset LD_LIBRARY_PATH
	unset LD_PRELOAD
}

# Taken from Magisk, used for System Mode installation
recovery_cleanup () {
	mv /sbin_tmp /sbin 2>/dev/null
	[ -z $OLD_PATH ] || export PATH=$OLD_PATH
	[ -z $OLD_LD_LIB ] || export LD_LIBRARY_PATH=$OLD_LD_LIB
	[ -z $OLD_LD_PRE ] || export LD_PRELOAD=$OLD_LD_PRE
}

##########################################################################################
# Magisk Mode Installation
##########################################################################################

magisk_install_setup () {
	ui_print " "
	ui_print "******************************"
	ui_print "Powered by Magisk (@topjohnwu)"
	ui_print "******************************"
	ui_print " "
	ui_print " > setup Magisk environment"

	if [ -f /data/adb/magisk/util_functions.sh ]; then
		NVBASE=/data/adb
		. /data/adb/magisk/util_functions.sh
	else
		error "Magisk version 15.0 or newer is required"
	fi

	if [ ${MAGISK_VER_CODE} -gt 18100 ]; then
		MOUNTPATH=${NVBASE}/modules
		MODPATH=${MOUNTPATH}/${MODID}

		# XXX when upgrading from Magisk 18.1 to 19.0 and flashing NanoDroid in one go,
		# XXX and NanoDroid installation logs exist, assume an upgrade
		[[ "$(find /data/adb -type f -name 'NanoDroid*')" && -f ${NVBASE}/magisk.img ]] && NANODROID_UPGRADE=1
		[[ -d "${STORAGE}/nanodroid_logs" && -f ${NVBASE}/magisk.img ]] && NANODROID_UPGRADE=1

		recovery_actions
	else
		error "Magisk version 19.0 or newer is required"
	fi

	case ${MODID} in
		NanoDroid )
			# check for sub-modules  which are not
			# supposed to be installed alongside
			for dir in NanoDroid_microG NanoDroid_FDroid; do
				if [ -d ${MOUNTPATH}/${dir} ]; then
					ui_print " !! ${dir} module detected - uninstalling!"
					rm -rf ${MOUNTPATH}/${dir}
					NANODROID_UPGRADE=1
				fi
			done
		;;

		NanoDroid_microG | NanoDroid_FDroid )
			# check for Full package and abort if found
			[ -d ${MOUNTPATH}/NanoDroid ] && \
				error "${MODID} can't be installed along side the Full package"
		;;

		NanoDroid_BromiteWebView | NanoDroid_OsmAnd )
			true
		;;

		* )
			error "unknown module intended to be installed!?"
		;;
	esac

	[ -d ${MODPATH} ] && NANODROID_UPGRADE=1
}

magisk_install_preinst () {
	if [ -f ${MODPATH}/system.prop ]; then
		ui_print " << backing up module's system.prop"
		cp ${MODPATH}/system.prop ${TMPDIR}/system.prop
	fi

	if [ -f ${MODPATH}/system/framework/services.jar ]; then
		ui_print " << backing up patched services.jar"
		cp ${MODPATH}/system/framework/services.jar ${TMPDIR}/services.jar
	fi

	if [ -d ${MODPATH}/logs ]; then
		ui_print " << backing up init.d script logs"
		cp -r ${MODPATH}/logs ${TMPDIR}/logs
	fi

	if [ -d ${MODPATH}/logcats ]; then
		ui_print " << backing up logcats"
		cp -r ${MODPATH}/logcats ${TMPDIR}/logcats
	fi
}

magisk_install_postinst () {
	if [ -f ${TMPDIR}/system.prop ]; then
		ui_print " << restoring system.prop"
		cp ${TMPDIR}/system.prop ${MODPATH}/system.prop
	fi

	if [ "${nanodroid_microg}" -ne 0 -o "${MODID}" = "NanoDroid_microG" ]; then
		if [ ! -z $(grep_prop ro.setupwizard.mode) ]; then
			echo "ro.setupwizard.mode=DISABLED" >> ${MODPATH}/system.prop
		fi
	fi

	if [ -d ${TMPDIR}/logs ]; then
		ui_print " << restoring init.d script logs"
		cp -r ${TMPDIR}/logs ${MODPATH}/logs
	fi

	if [ -d ${TMPDIR}/logcats ]; then
		ui_print " << restoring logcats"
		cp -r ${TMPDIR}/logcats ${MODPATH}/logcats
	fi

	if [ -f ${TMPDIR}/services.jar ]; then
		ui_print " << restoring patched services.jar"
		mkdir -p ${MODPATH}/system/framework
		cp ${TMPDIR}/services.jar ${MODPATH}/system/framework/services.jar
	fi
}

magisk_install_finish () {
	# Magisk Module files
	cp -af ${INSTALLER}/module.prop ${MODPATH}/module.prop

	if [ -f ${INSTALLER}/service.sh ]; then
		cp -af ${INSTALLER}/service.sh ${MODPATH}/service.sh
		chmod +x ${MODPATH}/service.sh
	fi

	case ${MODID} in
		NanoDroid | NanoDroid_microG )
			magisk_install_postinst
		;;
	esac

	if [ "${nanodroid_fonts}" -eq 1 -a ! -z ${CUSTOM_FONT} ]; then
		ui_print " << Restore NanoDroid-Font (${CUSTOM_FONT})"
		${NANODROID_BINDIR}/nanodroid-font -s "${CUSTOM_FONT}"
	fi

	recovery_cleanup
}

##########################################################################################
# Destroy all GApps!
##########################################################################################

gapps_solve_conflicts () {
	# first get rid of conflicting packages
	print_google_apps | while read app; do
		echo " ++ removing app: ${app} [google_apps]"
		${NANODROID_BINDIR}/nanodroid-overlay --add ${app}

		rm -rf /data/dalvik-cache/*/system"@priv-app@${app}"[@\.]*@classes.*
		rm -rf /data/dalvik-cache/*/system"@app@${app}"[@\.]*@classes.*
	done

	print_google_data | while read app; do
		echo " ++ removing data for: ${app} [google_data]"
		rm -rf /data/data/${app}
		rm -rf /data/user/*/${app}
		rm -rf /data/user_de/*/${app}
		rm -rf /data/app/${app}-*
		rm -rf /mnt/asec/${app}-*
		rm -rf ${STORAGE}/Android/data/${app}
	done
}

gapps_destroy_artifacts () {
	# this removes original Play Services
	# only if this is a fresh NanoDroid installation
	if [ "${NANODROID_UPGRADE}" -eq 0 ]; then
		rm -rf /data/dalvik-cache/*/system"@priv-app@GmsCore"[@\.]*@classes.*

		print_google_data_dirty | while read app; do
			echo " ++ removing data for: ${app} [google_data_dirty]"
			rm -rf /data/data/${app}
			rm -rf /data/user/*/${app}
			rm -rf /data/user_de/*/${app}
			rm -rf /data/app/${app}-*
			rm -rf /mnt/asec/${app}-*
			rm -rf ${STORAGE}/Android/data/${app}
		done

		find /data/system* -type f -name 'accounts*db' 2>/dev/null | while read database; do
			echo "  ++ deleting Google Accounts from ${database} (if any)"
			${INSTALLER}/sqlite3.${BIN_ARCH} ${database} \
				"DELETE FROM accounts WHERE type='com.google';"
		done

		find /data/system/users -type f -name 'runtime-permissions.xml' 2>/dev/null | while read file; do
			if grep -q "com.google.android" "${file}"; then
				rm -f "${file}"
				echo "  ++ resetting permissions: ${file}"
			fi
		done

		if [ -f /data/system/packages.list ]; then
			print_google_data_dirty | while read app; do
				echo "  ++ de-registering app: ${app} (if installed)"
				sed -e "/${app}/d" -i /data/system/packages.list
			done
		fi
	fi
}

##########################################################################################
# check if ROM has native fake signature spoofing support
# by @ale5000
##########################################################################################

check_fake_package_signature () {
	PERMISSION=android.permission.FAKE_PACKAGE_SIGNATURE
	PERMISSION_OD=$(echo -n "${PERMISSION}" | od -A n -t x1 | tr -d '\n' | sed -e 's/^ //g;s/ /00/g')
	HAS_FAKESIGN=false

	FW_RES_DIR="${TMPDIR}/framework-res"
	FW_RES_FILE="${FW_RES_DIR}/AndroidManifest.xml"

	if [ ! -f ${FW_RES_FILE} ]; then
		mkdir -p "${FW_RES_DIR}"
		"${UNZIP}" -oq /system/framework/framework-res.apk -d "${FW_RES_DIR}"
	fi

	grep -qF "${PERMISSION}" "${FW_RES_FILE}" && HAS_FAKESIGN=true
	od -A n -t x1 "${FW_RES_FILE}" | tr -d ' \n' | grep -qF "${PERMISSION_OD}" && HAS_FAKESIGN=true

	${HAS_FAKESIGN} && return 0 || return 1
}

##########################################################################################
# check if Bromite System WebView is supported
##########################################################################################

check_bromite_webview_support () {
	WEBVIEW_PKG="com.android.webview"
	HAS_WEBVIEW=false

	FW_RES_DIR="${TMPDIR}/framework-res"
	FW_RES_FILE="${FW_RES_DIR}/res/xml/config_webview_packages.xml"

	if [ ! -f ${FW_RES_FILE} ]; then
		mkdir -p "${FW_RES_DIR}"
		"${UNZIP}" -oq /system/framework/framework-res.apk -d "${FW_RES_DIR}"
	fi

	grep -qF "${WEBVIEW_PKG}" "${FW_RES_FILE}" && HAS_WEBVIEW=true

	${HAS_WEBVIEW} && return 0 || return 1
}

##########################################################################################
# privapp permission whitelist generation
##########################################################################################

dump_system_privapp_permissions () {
	SYS_LIST="${TMPDIR}/privapp-permissions.list"

	# XXX this looks shitty
	"${AAPT}" dump xmltree /system/framework/framework-res.apk AndroidManifest.xml | \
		tr -d '\n' | sed -e 's/E:/\n/g' | grep '(type 0x11)0x[137]2' | \
		awk -F\" '{print $2}' | sort > "${SYS_LIST}"

	# XXX pre-patched custom ROM
	check_fake_package_signature && \
		echo "android.permission.FAKE_PACKAGE_SIGNATURE" >> "${SYS_LIST}"
}

create_privapp_permissions_whitelist () {
	APK="${MODPATH}/system/priv-app/${1}/${1}.apk"
	APK_NAME="$("${AAPT}" dump badging "${APK}" | awk -F \' '/^package: name/{print $2}')"
	APK_LIST="${TMPDIR}/${APK_NAME}.list"

	SYS_LIST="${TMPDIR}/privapp-permissions.list"

	APP_WHITELIST="${TMPDIR}/${APK_NAME}.xml"
	INST_WHITELIST="/system/etc/permissions/${APK_NAME}.xml"

	[ ! -f "${SYS_LIST}" ] && dump_system_privapp_permissions

	"${AAPT}" dump permissions "${APK}" | \
		awk -F \' '/^uses-permission:/{print $2}' | \
		sort > "${APK_LIST}"

	echo '<?xml version="1.0" encoding="utf-8"?>
<permissions>
    <privapp-permissions package="'${APK_NAME}'">' > "${APP_WHITELIST}"

	cat "${APK_LIST}" | while read perm; do
		if grep -q "${perm}" "${SYS_LIST}"; then
			echo "  ++ package ${APK_NAME} needs privapp-whitelist ${perm}"
			echo '        <permission name="'${perm}'" />' >> "${APP_WHITELIST}"
		fi
	done

	echo '    </privapp-permissions>
</permissions>' >> "${APP_WHITELIST}"

	mkdir -p "${MODPATH}/system/etc/permissions/"
	cp "${APP_WHITELIST}" "${MODPATH}/${INST_WHITELIST}"
	set_perm_data "${MODPATH}/${INST_WHITELIST}"
	installinfo_add "${INST_WHITELIST}"
}

##########################################################################################
# Generic Installation
##########################################################################################

install_microg () {
	# install microG if requested
	# respectively force if it's the microG package
	if [ "${nanodroid_microg}" -ne 0 -o "${MODID}" = "NanoDroid_microG" ]; then

		gapps_solve_conflicts
		gapps_destroy_artifacts

		NLPBACKEND="nlpBackendNominatim"

		ui_print " << with microg"
		ui_print "   ++ Nominatim geocoder backend"
		${NANODROID_BINDIR}/nanodroid-overlay --add NominatimGeocoderBackend
		${NANODROID_BINDIR}/nanodroid-overlay --add NominatimNlpBackend

		if [ "${nanodroid_nlpbackend:0:1}" -eq 1 ]; then
			NLPBACKEND="${NLPBACKEND} nlpBackendDejavu"
			ui_print "   ++ Déjà Vu location backend"
			${NANODROID_BINDIR}/nanodroid-overlay --add DejaVuNlpBackend
			${NANODROID_BINDIR}/nanodroid-overlay --add DejaVuBackend
		fi

		if [ "${nanodroid_nlpbackend:1:1}" -eq 1 ]; then
			NLPBACKEND="${NLPBACKEND} nlpBackendIchnaea"
			ui_print "   ++ Ichnaea location backend"
			${NANODROID_BINDIR}/nanodroid-overlay --add IchnaeaNlpBackend
			${NANODROID_BINDIR}/nanodroid-overlay --add MozillaNlpBackend
		fi

		if [ "${nanodroid_nlpbackend:2:1}" -eq 1 ]; then
			NLPBACKEND="${NLPBACKEND} nlpBackendApple"
			ui_print "   ++ Apple location backend"
		fi

		if [ "${nanodroid_nlpbackend:3:1}" -eq 1 ]; then
			NLPBACKEND="${NLPBACKEND} nlpBackendRadiocell"
			ui_print "   ++ Radiocell location backend"
		fi

		# migrate from Nanolx microG GmsCore to Official microG GmsCore
		detect_migrate_microg

		ui_print "   ++ microG GmsCore"
		nanodroid_install_apk GmsCore

		if [ "${nanodroid_microg}" -ne 2 ]; then
			for app in GsfProxy DroidGuard; do
				nanodroid_install_apk ${app}
			done

			${NANODROID_BINDIR}/nanodroid-overlay --add GmsDroidGuard
		fi

		for app in ${NLPBACKEND}; do
			nanodroid_install_apk ${app}
		done

		create_privapp_permissions_whitelist GmsCore

		nanodroid_install_file etc/permissions/features.xml
		nanodroid_install_file etc/default-permissions/microg-permissions.xml
		nanodroid_install_file etc/sysconfig/microg-a5k.xml

	else	ui_print " << without microG"
	fi
}

install_mapsv1 () {
	# install mapsv1 if requested
	if [ "${nanodroid_mapsv1}" -eq 1 ]; then
		ui_print " << with Maps API version 1"
		nanodroid_install_file etc/permissions/com.google.android.maps.xml
		nanodroid_install_file framework/com.google.android.maps.jar
	else	ui_print " << without Maps API version 1"
	fi
}

install_gsync () {
	# install GSync if requested
	if [ "${nanodroid_gsync}" -eq 1 ]; then
		if [ "${GSYNC_UNSUPPORTED}" -eq 1 ]; then
			ui_print " << Google Sync Adapters are unsupported on SDK ${SDK_VERSION}"
		else
			ui_print " << with Google Sync Adapters (${GSYNC_VER})"

			for app in GoogleCalendarSync GoogleContactsSync GoogleBackupTransport; do
				nanodroid_install_apk ${app}
			done

			create_privapp_permissions_whitelist GoogleBackupTransport
			nanodroid_install_file etc/default-permissions/google-sync-permissions.xml
		fi
	else	ui_print " << without Google Sync Adapters"
	fi
}

install_fdroid () {
	# install F-Droid if requested
	# respectively force if it's the F-Droid package

	if [ "${nanodroid_fdroid}" -eq 2 ]; then
		ui_print " << with Aurora Droid"
		nanodroid_install_apk AuroraDroid
		nanodroid_install_apk AuroraServices
		create_privapp_permissions_whitelist AuroraServices
	elif [ "${nanodroid_fdroid}" -eq 1 -o "${MODID}" = "NanoDroid_FDroid" ]; then
		ui_print " << with F-Droid"
		nanodroid_install_apk FDroid
		nanodroid_install_apk FDroidPrivileged

		${NANODROID_BINDIR}/nanodroid-overlay --add FDroidPriv

		create_privapp_permissions_whitelist FDroidPrivileged
		nanodroid_install_file etc/org.fdroid.fdroid/additional_repos.xml
	else	ui_print " << without F-Droid"
	fi
}

install_apps () {
	# install apps if requested
	if [ "${nanodroid_apps}" -eq 1 ]; then
		ui_print " << with applications"
		APP_STRING=" <<>"

		INSTALL_APPS=$(cat "${cfg_apps}")
		for app in ${INSTALL_APPS}; do
			if [[ -d /system/app/${app} ]]; then
				ui_print "   ++ app: ${app} already provided by ROM"
			elif [[ -d "${INSTALLER}/system/app/${app}" ]]; then
				ui_print "   ++ ${app}"
				nanodroid_install_apk ${app}
			else	ui_print "   ++ app: ${app} missing"
			fi
		done
	else	ui_print " << without applications"
	fi
}

install_store () {
	STORE_CHOICE=${nanodroid_play:0:1}
	FAKE_STORE=${nanodroid_play:1:1}

	[ "${FAKE_STORE}" -eq 1 ] && STORE_CONFLICT="Phonesky" || STORE_CONFLICT=""

	# install Yalp, Aurora or Play Store whichever requested
	case "${STORE_CHOICE}" in
		1 )
			# force unselect Fake Store when user has choosen Play Store
			STORE_CONFLICT="FakeStore"
			FAKE_STORE=0

			ui_print " << with Play Store"
			nanodroid_install_apk Phonesky

			create_privapp_permissions_whitelist Phonesky

			nanodroid_install_file etc/default-permissions/phonesky-permissions.xml
		;;

		2 )
			ui_print " << with Yalp Store"
			nanodroid_install_apk YalpStore
			create_privapp_permissions_whitelist YalpStore
		;;

		3 )
			ui_print " << with Aurora Store"
			nanodroid_install_apk AuroraStore
			nanodroid_install_apk AuroraServices
			create_privapp_permissions_whitelist AuroraServices
		;;

		* )
			ui_print " << without App Store"
		;;
	esac

	# Only install Fake Store if requested and Play Store is not installed
	if [ "${FAKE_STORE}" -eq 1 ]; then
		ui_print " << with Fake Store"
		nanodroid_install_apk FakeStore

		create_privapp_permissions_whitelist FakeStore
	else 	ui_print " << without Fake Store"
	fi

	if [ ! -z "${STORE_CONFLICT}" ]; then
		${NANODROID_BINDIR}/nanodroid-overlay --add ${STORE_CONFLICT}

		if [ "${NANODROID_UPGRADE}" -eq 0 ]; then
			rm -rf /data/data/com.android.vending
			rm -rf /data/user/*/com.android.vending
			rm -rf /data/user_de/*/com.android.vending
			rm -rf /data/app/com.android.vending-*
		fi
	fi
}

install_zelda () {
	# install Zelda Ringtones when requested
	if [ "${nanodroid_zelda}" -eq 1 ]; then
		ui_print " << with Zelda sounds"
		nanodroid_install_dir media
	else	ui_print " << without Zelda sounds"
	fi
}

install_bash () {
	if [ "${nanodroid_bash}" -eq 1 ]; then
		ui_print " << with GNU Bash Shell"
		nanodroid_install_file etc/bash_logout
		nanodroid_install_file etc/bashrc

		nanodroid_install_file xbin/bash bin
		nanodroid_install_file xbin/bash.bin.${BIN_ARCH} bin
		nanodroid_install_file xbin/bashbug.${BIN_ARCH} bin
		nanodroid_install_file xbin/less bin
		nanodroid_install_file xbin/less.bin.${BIN_ARCH} bin
	else	ui_print " << without GNU Bash Shell"
	fi
}

install_nanodroidscripts () {
	ui_print " << with NanoDroid Scripts"

	for script in npem nutl novl \
		nanodroid-perm nanodroid-util \
		nanodroid-overlay; do
		nanodroid_install_file xbin/${script} bin
	done

	nanodroid_substitute xbin/nanodroid-overlay

	if [ "${MODE}" = "MAGISK" ]; then
		for script in nprp nanodroid-prop; do
			nanodroid_install_file xbin/${script} bin
		done

		nanodroid_substitute xbin/nanodroid-prop
	fi
}

install_fonts () {
	if [ "${nanodroid_fonts}" -eq 1 ]; then
		ui_print " << with Nintendo Fonts"
		nanodroid_install_file xbin/nanodroid-font bin
		nanodroid_substitute xbin/nanodroid-font
		nanodroid_install_file xbin/nfnt bin

		nanodroid_install_dir fonts
	fi
}

install_nano () {
	if [ "${nanodroid_nano}" -eq 1 ]; then
		ui_print " << with GNU Nano Terminal Editor"
		nanodroid_install_dir etc/terminfo

		nanodroid_install_file xbin/nano bin
		nanodroid_install_file xbin/nano.bin bin
	else	ui_print " << without GNU Nano Terminal Editor"
	fi
}

install_shell_utils () {
	if [ "${nanodroid_utils}" -eq 1 ]; then
		ui_print " << with Shell Utilities"

		# architecture dependend stuff
		for binary in col colcrt colrm column findfs findmnt \
			hexdump lessecho lesskey look lsblk lscpu lsipc \
			lslocks lsns ncal setterm whereis; do
			nanodroid_install_file xbin/${binary}.${BIN_ARCH} bin
		done
	else	ui_print " << without Shell Utilities"
	fi
}

install_initd () {
	if [ "${nanodroid_init}" -eq 1 ]; then
		ui_print " << with init scripts"

		if [ "${MODE}" = "SYSTEM" ]; then
			INIT_BASE="${MODPATH}/system/etc/init.d"
		else	INIT_BASE="${MODPATH}/init.d"
		fi

		mkdir -p "${INIT_BASE}"
		cp "${INSTALLER}/system/etc/init.d"/* "${INIT_BASE}/"
		set_perm_bin "${INIT_BASE}"

		for init in 10_sqlite 20_fstrim 30_logcat 40_external_sd 50_logscleaner; do
			installinfo_add "/system/etc/init.d/${init}"
		done
	else	ui_print " << without init scripts"
	fi
}

install_bromite_webview () {
	if [ "${MODID}" = "NanoDroid_BromiteWebView" ]; then
		if ! check_bromite_webview_support; then
			error "ROM does not support Bromite WebView installation!"
		else
			ui_print " << with Bromite WebView"

			case ${ARCH} in
				arm | arm64 | x86 ) BROMITE_ARCH=${ARCH} ;;
				x86_64 ) BROMITE_ARCH=x86 ;;
			esac

			WEBVIEW_REPLACE=BromiteWebView
			BACKUP_PATH="${STORAGE}/nanodroid_backups/$(grep_prop ro.build.flavor)_$(grep_prop ro.build.id)"

			for app in webview webviewstub WebViewStub Webview; do
				if [ -d /system/app/${app} ]; then
					if [ "${MODE}" = "SYSTEM" ]; then
						echo "    backing up ${app} to ${BACKUP_PATH}/app/${app}"
						mkdir -p "${BACKUP_PATH}/app"
						rm -rf "${BACKUP_PATH}/app/${app}"
						mv /system/app/${app} "${BACKUP_PATH}/app/"
					fi

					WEBVIEW_REPLACE=${app}
					break
				fi
			done

			if [ "${NANODROID_UPGRADE}" -eq 0 ]; then
				for app in com.android.webview; do
					rm -rf /data/data/${app}
					rm -rf /data/user/*/${app}
					rm -rf /data/user_de/*/${app}
					rm -rf /data/app/${app}-*
					rm -rf /mnt/asec/${app}-*
					rm -rf ${STORAGE}/Android/data/${app}
				done
			fi

			nanodroid_install_apk BromiteWebView_${BROMITE_ARCH} multilib ${WEBVIEW_REPLACE}
		fi
	fi
}

install_osmand () {
	if [ "${MODID}" = "NanoDroid_OsmAnd" ]; then
		ui_print " << with OsmAnd"
		nanodroid_install_apk OsmAnd
		nanodroid_install_apk OsmAnd_ContourLines
	fi
}

install_swipe () {
	if [ "${nanodroid_swipe}" -eq 1 ]; then
		if [ "${SWIPE_UNSUPPORTED}" -eq 1 ]; then
			ui_print " << Swipe Libraries are unsupported on SDK ${SDK_VERSION}"
		else
			ui_print " << with swipe libraries"

			SWIPE_SRC="${INSTALLER}/swipe/${ARCH}"
			SWIPE_DEST="/system/${SWIPE_LIBDIR}"

			mkdir -p "${MODPATH}${SWIPE_DEST}"

			cp "${SWIPE_SRC}/libjni_keyboarddecoder.so" "${MODPATH}${SWIPE_DEST}" || \
				error "failed to install libjni_keyboarddecoder.so"
			set_perm_data "${MODPATH}${SWIPE_DEST}/libjni_keyboarddecoder.so"

			cp "${SWIPE_SRC}/${LIBJNI_IME}" "${MODPATH}${SWIPE_DEST}/libjni_latinimegoogle.so" || \
				error "failed to install libjni_latinimegoogle.so"
			set_perm_data "${MODPATH}${SWIPE_DEST}/libjni_latinimegoogle.so"

			installinfo_add "${SWIPE_DEST}/libjni_keyboarddecoder.so"
			installinfo_add "${SWIPE_DEST}/libjni_latinimegoogle.so"
		fi
	else	ui_print " << without swipe libraries"
	fi
}

install_addond () {
	if [ -d /system/addon.d ]; then
		ui_print " << System Mode OTA survival"

		cp "${INSTALLER}/CommonAddon" "/system/addon.d/91-nanodroid.sh" || \
			error "failed to install System Mode OTA survival"

		chmod 0755 "/system/addon.d/91-nanodroid.sh"
		sed -e "s|@MODID@|${MODID}|g" -i "/system/addon.d/91-nanodroid.sh"
	else
		ui_print " << ROM does not have addon.d support"
	fi
}

##########################################################################################
# Advanced Installation Functions
##########################################################################################

nanodroid_install_dir () {
	dir="${1}"
	dest="/system/${dir}"

	[ ! -d "${INSTALLER}/system/${dir}" ] && \
		error "dir: ${dir} not found"

	echo "    installing dir: ${dir}"

	mkdir -p "${MODPATH}${dest}"
	cp -r "${INSTALLER}/system/${dir}"/* "${MODPATH}${dest}/" || \
		error "failed to install ${dir}"

	case ${2} in
		bin ) set_perm_bin -r "${MODPATH}${dest}" ;;
		*   ) set_perm_data -r "${MODPATH}${dest}" ;;
	esac

	find "${INSTALLER}/system/${dir}" -type f | \
			sed -e "s,^${INSTALLER},,g" | \
			installinfo_add
}

nanodroid_install_apk () {
	app=${1}
	multilib=${2}
	alias=${3}

	unset prefix
	unset source

	for sdir in system/app system/priv-app gsync/common/app \
		gsync/${GSYNC_VER}/app gsync/${GSYNC_VER}/priv-app; do
		if [ -f "${INSTALLER}/${sdir}/${app}/${app}.apk.gz" ]; then
			source="${INSTALLER}/${sdir}/${app}/${app}.apk"
			dir=system/$(basename ${sdir})
			break
		fi
	done

	[ -z "${source}" ] && error "app ${app} not found"

	if [ "${UNFOLD_APP_DIR}" -eq 1 ]; then
		dest="${MODPATH}/${dir}"
	else
		if [ -z "${alias}" ]; then
			dest="${MODPATH}/${dir}/${app}"
		else	dest="${MODPATH}/${dir}/${alias}"
		fi
	fi

	if [ ! -z "${alias}" ]; then
		dest_apk=${alias}.apk
	else	dest_apk=${app}.apk
	fi

	mkdir -p "${dest}"

	echo "    installing app: ${app}"
	echo "      from: ${source}"
	echo "      into: ${dest} [${dest_apk}]"
	cp "${source}.gz" "${dest}/${dest_apk}.gz" || \
		error "failed to install ${source} to ${dest}"

	gzip -fd "${dest}/${dest_apk}.gz" || \
		error "failed to decompress ${dest}/${dest_apk}.gz"

	installinfo_add "${dest}/${dest_apk}"

	nanodroid_install_lib "${dest}/${dest_apk}" "${2}"

	set_perm_data -r "${dest}"
}

nanodroid_install_file () {
	dir="$(dirname "${1}")"
	file="$(basename "${1}")"
	unset source

	for sdir in system gsync; do
		if [ -f "${INSTALLER}/${sdir}/${dir}/${file}" ]; then
			source="${INSTALLER}/${sdir}/${dir}/${file}"
			break
		fi
	done

	[ -z "${source}" ] && error "file: ${file} not found"

	# if /system/xbin does not exist, use /system/bin
	[ "${dir}" = "xbin" -a "${ROM_NO_XBIN}" -eq 1 ] && xdir="bin" || xdir="${dir}"

	# strip off .${BIN_ARCH} from final filename (if any)
	xfile=$(basename ${file} .${BIN_ARCH})

	echo "    installing file: ${xfile}"

	mkdir -p "${MODPATH}/system/${xdir}/"
	cp "${source}" "${MODPATH}/system/${xdir}/${xfile}" || \
		error "failed to install ${xfile}"

	case ${2} in
		bin ) set_perm_bin "${MODPATH}/system/${xdir}/${xfile}" ;;
		*   ) set_perm_data "${MODPATH}/system/${xdir}/${xfile}" ;;
	esac

	installinfo_add "/system/${xdir}/${xfile}"
}

nanodroid_install_lib () {
	apk="${1}"
	dest="$(dirname ${1})"
	multilib="${2}"

	unset libd

	if [ "${UNFOLD_APP_DIR}" -eq 1 ]; then
		case ${ARCH} in
			arm | x86 )      libd=${MODPATH}/system/lib   ;;
			arm64 | x86_64 ) libd=${MODPATH}/system/lib64 ;;
		esac
	else
		libd=${dest}/lib
	fi

	rm -rf ${TMP_LIBDIR}
	mkdir -p ${TMP_LIBDIR}

	unset srcdir

	"${UNZIP}" -oq "${apk}" "lib/*" -d "${TMP_LIBDIR}" \
		2>/dev/null
	unzip_return=$?

	case ${unzip_return} in
		0  ) echo "      ${app} does have libs" ;;
		11 ) echo "      ${app} does not have any libs" ;;
		50 ) error "  not enough space available!" ;;
		*  ) error "  unpacking libs for ${app} failed [${unzip_return}]" ;;
	esac

	if [ -d ${TMP_LIBDIR}/lib ]; then
		for ARCHLIB in ${LIB_ARCHES}; do
			if [ -d ${TMP_LIBDIR}/lib/${ARCHLIB} ]; then
				srcdir=${TMP_LIBDIR}/lib/${ARCHLIB}

				case ${srcdir} in
					*arm64*  ) echo "      ${app}: installing arm64 libs"
						   lib_arch=arm64 ;;
					*arm*	 ) echo "      ${app}: installing arm libs"
						   lib_arch=arm ;;
					*x86_64* ) echo "      ${app}: installing x86_64 libs"
						   lib_arch=x86_64 ;;
					*x86*	 ) echo "      ${app}: installing x86 libs"
						   lib_arch=x86 ;;
				esac

				echo "        from: ${srcdir}"
				echo "        into: ${libd}/${lib_arch}"
				mkdir -p "${libd}/${lib_arch}"

				for lib in ${srcdir}/*; do
					echo "        library: $(basename ${lib})"
					cp ${lib} "${libd}/${lib_arch}/" || \
						error "  installing libs for ${app} failed"

					installinfo_add "${libd}/${lib_arch}/$(basename ${lib})"
				done

				[ -z "${multilib}" ] && break
			fi
		done
	fi
}

nanodroid_substitute () {
	dir="$(dirname "${1}")"
	file="$(basename "${1}")"

	# if /system/xbin does not exist, use /system/bin
	[ "${dir}" = "xbin" -a "${ROM_NO_XBIN}" -eq 1 ] && dir="bin"

	target="${MODPATH}/system/${dir}/${file}"

	[ ! -f "${target}" ] && error "file: ${file} not found"

	if grep -q @ZIPDIR@ "${target}"; then
		if [[ "${ZIPDIR}" == "/external_sd" ]] || [[ "${ZIPDIR}" == "/sdcard1" ]]; then
			# /external_sd is already known by `nanodroid-overlay`
			# no need to add it a second time
			sed -e 's|@ZIPDIR@||' -i ${target}
			echo "    substitute: remove @ZIPDIR@ in ${target}"
		else
			sed -e "s|@ZIPDIR@|${ZIPDIR}|g" -i ${target}
			echo "    substitute: adjust @ZIPDIR@ in ${target}"
		fi
	fi

	if grep -q @MODPATH@ ${target}; then
		sed -e "s|@MODPATH@|${MODPATH}|g" -i ${target}
		echo "    substitute: adjust @MODPATH@ in ${target}"
	fi
}

nanodroid_storelogs () {

	curdate=$(date +%Y%m%d_%H.%M.%S)
	nanodroid_logfile="${STORAGE}/nanodroid_logs/${MODID}_${VERSION}_log_${curdate}.log"
	nanodroid_twrplog="${STORAGE}/nanodroid_logs/${MODID}_${VERSION}_twrp_${curdate}.log"

	mkdir -p "${STORAGE}/nanodroid_logs"

	echo "\

Installation successful: ${INSTALL_SUCCESS}

### VALUES ###
ZIP=${ZIP}
ZIPDIR=${ZIPDIR}
TMPDIR=${TMPDIR}
TMP_LIBDIR=${TMP_LIBDIR}
INSTALLER=${INSTALLER}
MODID=${MODID}
SDK_VERSION=${SDK_VERSION}
ARCH=${ARCH}
LIB_ARCHES=${LIB_ARCHES}
MODPATH=${MODPATH}
SWIPE_LIBDIR=${SWIPE_LIBDIR}
MODE=${MODE}
MAGISK_VER_CODE=${MAGISK_VER_CODE}
CUSTOM_FONT=${CUSTOM_FONT}
ROM_NO_XBIN=${ROM_NO_XBIN}
NANODROID_UPGRADE=${NANODROID_UPGRADE}
NANODROID_BINDIR=${NANODROID_BINDIR}
HAS_FAKESIGN=${HAS_FAKESIGN}
HAS_WEBVIEW=${HAS_WEBVIEW}

### MOUNTED PARTITIONS ###
" >> ${nanodroid_logfile}

mount | awk '{print $1 " on " $3 " params: " $6}' \
	>> ${nanodroid_logfile}

echo "
### PARTITION INFORMATION ###

DEVICE_AB=${DEVICE_AB}
VENDOR_COMPAT=${VENDOR_COMPAT}
SYSTEM_AS_ROOT=${SYSTEM_AS_ROOT}
SYSTEMBLOCK=${SYSTEMBLOCK}
VENDORBLOCK=${VENDORBLOCK}

### DISK USAGE ###
" >> ${nanodroid_logfile}

df 2>/dev/null | sed '/^\//d' >> ${nanodroid_logfile}

if [ ! -z "${cfg_setup}" ]; then

echo "
### SETUP ###

configuration: ${cfg_setup}
" >> ${nanodroid_logfile}

cat "${cfg_setup}" >> ${nanodroid_logfile}

fi

if [ ! -z "${cfg_apps}" ]; then

echo "
### APPS ###

configuration: ${cfg_apps}
" >> ${nanodroid_logfile}

cat "${cfg_apps}" >> ${nanodroid_logfile}

fi

if [ ! -z "${cfg_overlay}" ]; then

echo "
### OVERLAY ###

configuration: ${cfg_overlay}
" >> ${nanodroid_logfile}

cat "${cfg_overlay}" >> ${nanodroid_logfile}

fi

chown root:sdcard_rw ${nanodroid_logfile}
chmod 0644 ${nanodroid_logfile}

cat /tmp/recovery.log > ${nanodroid_twrplog}

chown root:sdcard_rw ${nanodroid_twrplog}
chmod 0644 ${nanodroid_twrplog}

ui_print " | storing installation logs in ${STORAGE}/nanodroid_logs/"
ui_print " | NanoDroid log:"
ui_print " || ""$(basename ${nanodroid_logfile})"
ui_print " | TWRP log:"
ui_print " || $(basename ${nanodroid_twrplog})"
ui_print " "

}

##########################################################################################
# NanoDroid Configuration File Handling
##########################################################################################

# check for configuration files
config_locations="${STORAGE} /external_sd /sdcard1 ${ZIPDIR} /data"

get_config () {
	config=""
	config_exists=0
	for path in ${config_locations}; do
		if test -r "${path}/.nanodroid-${1}"; then
			config="${path}/.nanodroid-${1}"
			config_exists=1
			return
		fi
	done
}

set_prop () {
	echo "${1}=${2}" >> "${cfg_setup}"
}

# check whether '.nanodroid-setup' has all required entries
check_cfg_setup () {
	source "${cfg_setup}"

	[ -z "${nanodroid_fdroid}" ] && set_prop nanodroid_fdroid 1
	[ -z "${nanodroid_microg}" ] && set_prop nanodroid_microg 1
	[ -z "${nanodroid_apps}" ] && set_prop nanodroid_apps 1

	[ -z "${nanodroid_play}" ] && set_prop nanodroid_play 10

	# in NanoDroid 20.3 nanodroid_play has changed
	if [ "${#nanodroid_play}" -lt 2 ]; then
		case "${nanodroid_play}" in
			0 ) tmp_prop="00" ;;
			1 ) tmp_prop="10" ;;
			2 ) tmp_prop="20" ;;
			3 ) tmp_prop="01" ;;
			4 ) tmp_prop="21" ;;
			* ) tmp_prop="10" ;;
		esac

		sed -e '/^nanodroid_play/d' -i "${cfg_setup}"
		set_prop nanodroid_play "${tmp_prop}"
	fi

	if [ "${MODID}" = "NanoDroid" ]; then
		[ -z "${nanodroid_overlay}" ] && set_prop nanodroid_overlay 1
	else	[ -z "${nanodroid_overlay}" ] && set_prop nanodroid_overlay 0
	fi

	[ -z "${nanodroid_zelda}" ] && set_prop nanodroid_zelda 1
	[ -z "${nanodroid_mapsv1}" ] && set_prop nanodroid_mapsv1 1
	[ -z "${nanodroid_init}" ] && set_prop nanodroid_init 1
	[ -z "${nanodroid_gsync}" ] && set_prop nanodroid_gsync 0
	[ -z "${nanodroid_forcesystem}" ] && set_prop nanodroid_forcesystem 0
	[ -z "${nanodroid_swipe}" ] && set_prop nanodroid_swipe 0

	[ -z "${nanodroid_nlpbackend}" ] && set_prop nanodroid_nlpbackend 100

	# in NanoDroid 20.3 nanodroid_nlpbackend has changed
	if [ "${#nanodroid_nlpbackend}" -eq 1 ]; then
		case "${nanodroid_nlpbackend}" in
			0 ) tmp_prop="000" ;;
			1 ) tmp_prop="100" ;;
			2 ) tmp_prop="010" ;;
			3 ) tmp_prop="110" ;;
			* ) tmp_prop="100" ;;
		esac

		sed -e '/^nanodroid_nlpbackend/d' -i "${cfg_setup}"
		set_prop nanodroid_nlpbackend "${tmp_prop}"
	fi

	# in NanoDroid 20.5 nanodroid_nlpbackend has changed
	if [ "${#nanodroid_nlpbackend}" -eq 3 ]; then
		tmp_prop="${nanodroid_nlpbackend}0"

		sed -e '/^nanodroid_nlpbackend/d' -i "${cfg_setup}"
		set_prop nanodroid_nlpbackend "${tmp_prop}"
	fi

	[ -z "${nanodroid_bash}" ] && set_prop nanodroid_bash 1
	[ -z "${nanodroid_nano}" ] && set_prop nanodroid_nano 1
	[ -z "${nanodroid_utils}" ] && set_prop nanodroid_utils 1
	[ -z "${nanodroid_fonts}" ] && set_prop nanodroid_fonts 1

	# in NanoDroid 21.0.90 nanodroid_override was dropped
	sed -e '/nanodroid_override/d' -i "${cfg_setup}"

	source "${cfg_setup}"
}

# check whether '.nanodroid-apps' is up to date
check_cfg_apps () {
	# <= 16.3 has KeePass DX instead of KeePassDroid, migrate
	grep -q KeePassDroid "${cfg_apps}" && sed -e 's/KeePassDroid/KeePassDX/g' -i "${cfg_apps}"

	# <= 17.7 has Substratum instead of Bucket (LibreSubtratum), migrate
	grep -q Bucket "${cfg_apps}" && sed -e 's/Bucket/Substratum/g' -i "${cfg_apps}"

	# <= 18.1 has Orfox instead of TorBrowser, migrate
	grep -q Orfox "${cfg_apps}" && sed -e 's/Orfox/TorBrowser/g' -i "${cfg_apps}"

	# <= 18.4 has Adaway instead of Blockada, migrate
	grep -q Adaway "${cfg_apps}" && sed -e 's/Adaway/Blokada/g' -i "${cfg_apps}"

	# >= 20.7.92 no longer ships YahooWeatherProvider, remove
	grep -q YahooWeatherProvider "${cfg_apps}" && sed -e '/YahooWeatherProvider/d' -i "${cfg_apps}"

	# >= 20.8.90 no longer ships OmniJAWS, remove
	grep -q OmniJAWS "${cfg_apps}" && sed -e '/OmniJAWS/d' -i "${cfg_apps}"

	# >= 21.0.90 has Alarmio instead of OmniClock, migrate
	grep -q OmniClock "${cfg_apps}" && sed -e 's/OmniClock/Alarmio/g' -i "${cfg_apps}"

	# >= 21.0.90 no longer ships OpenWeatherMapProvider, remove
	grep -q OpenWeatherMapProvider "${cfg_apps}" && sed -e '/OpenWeatherMapProvider/d' -i "${cfg_apps}"

	# >= 21.0.90 has Lightning instead of Privacy Browser, migrate
	grep -q Lightning "${cfg_apps}" && sed -e 's/Lightning/PrivacyBrowser/g' -i "${cfg_apps}"

	# >= 21.0.90 has Hacker's Keyboard instead of BeHeKeyboard, migrate
	grep -q BeHeKeyboard "${cfg_apps}" && sed -e 's/BeHeKeyboard/HackersKeyboard/g' -i "${cfg_apps}"

	# >= 22.1 has SmartPack-Kernel-Manager instead of Kernel Adiutor, migrate
	grep -q KernelAdiutor "${cfg_apps}" && sed -e 's/KernelAdiutor/SmartPackKernelManager/g' -i "${cfg_apps}"
}

# check whether '.nanodroid-overlay' is up to date
check_cfg_overlay () {
	# 22.0 flagged the following for overlay creation which caused issues
	grep -q "^GmsCore$" "${cfg_overlay}" && sed '/^GmsCore$/d' -i "${cfg_overlay}"
	grep -q "^GsfProxy$" "${cfg_overlay}" && sed '/^GsfProxy$/d' -i "${cfg_overlay}"
	grep -q "^DroidGuard$" "${cfg_overlay}" && sed '/^DroidGuard$/d' -i "${cfg_overlay}"
}

get_cfg_setup () {
	get_config setup
	if [ "$config_exists" -eq 1 ]; then
		cfg_setup="${config}"
		check_cfg_setup
		ui_print " > Config | nanodroid-setup   | $(dirname ${cfg_setup})"
	else
		cfg_setup="${INSTALLER}/.nanodroid-setup"
		source "${cfg_setup}"
		ui_print " > Config | nanodroid-setup   | fallback"
	fi
}

get_cfg_overlay () {
	get_config overlay
	if [ "$config_exists" -eq 1 ]; then
		cfg_overlay="${config}"
		check_cfg_overlay
		ui_print " > Config | nanodroid-overlay | $(dirname ${cfg_overlay})"
	else
		cfg_overlay="${INSTALLER}/.nanodroid-overlay"
		ui_print " > Config | nanodroid-overlay | fallback"
	fi
}

get_cfg_apps () {
	get_config apps
	if [ "$config_exists" -eq 1 ]; then
		cfg_apps="${config}"
		check_cfg_apps
		ui_print " > Config | nanodroid-apps    | $(dirname ${cfg_apps})"
	else
		cfg_apps="${INSTALLER}/.nanodroid-apps"
		ui_print " > Config | nanodroid-apps    | fallback"
	fi
}