rootAVD.sh

#!/usr/bin/env bash
##########################################################################################
#
# Magisk Boot Image Patcher - original created by topjohnwu and modded by shakalaca's
# modded by NewBit XDA for Android Studio AVD
##########################################################################################

###################
# Helper Functions
###################

# Copied 1 to 1 from topjohnwu
# This code block seems to be a generic utility function for extracting the parent directory of a given path. It does not contain any inherently malicious functionality.
getdir() {
  case "$1" in
    */*) dir=${1%/*}; [ -z $dir ] && echo "/" || echo $dir ;;
    *) echo "." ;;
  esac
}

# This code block appears to be responsible for retrieving and setting various flags and variables related to the system configuration and state. It doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
get_flags() {
	echo "[-] Get Flags"

	if [ -f /system/init -o -L /system/init ]; then
    	SYSTEM_ROOT=true
  	else
    	SYSTEM_ROOT=false
    	grep ' / ' /proc/mounts | grep -qv 'rootfs' || grep -q ' /system_root ' /proc/mounts && SYSTEM_ROOT=true
  	fi

	if [ -z $KEEPVERITY ]; then
		if $SYSTEM_ROOT; then
			KEEPVERITY=true
			echo "[*] System-as-root, keep dm/avb-verity"
		else
			KEEPVERITY=false
		fi
	fi

	ISENCRYPTED=false
	grep ' /data ' /proc/mounts | grep -q 'dm-' && ISENCRYPTED=true
	[ "$(getprop ro.crypto.state)" = "encrypted" ] && ISENCRYPTED=true

	if [ -z $KEEPFORCEENCRYPT ]; then
		# No data access means unable to decrypt in recovery
		if $ISENCRYPTED || ! $DATA; then
			KEEPFORCEENCRYPT=true
			echo "[-] Encrypted data, keep forceencrypt"
		else
			KEEPFORCEENCRYPT=false
		fi
	fi
	
	RECOVERYMODE=false
	
	if [[ $API -eq 28 ]]; then
		RECOVERYMODE=true
	fi

	export RECOVERYMODE
	export KEEPVERITY
	export KEEPFORCEENCRYPT
	echo "[*] RECOVERYMODE=$RECOVERYMODE"
	echo "[-] KEEPVERITY=$KEEPVERITY"
	echo "[*] KEEPFORCEENCRYPT=$KEEPFORCEENCRYPT"
}

# This code block seems to be responsible for copying files from specific directories to the base directory ($BASEDIR), renaming some of the files, and setting the permissions. It doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
copyARCHfiles() {	
	BINDIR=$BASEDIR/lib/$ABI
	ASSETSDIR=$BASEDIR/assets
	STUBAPK=false

	if [ -e $BINDIR/libstub.so ]; then
		ABI=$ARCH32
		BINDIR=$BASEDIR/lib/$ABI
		echo "[*] No 64-Bit Binarys found, please consider Magisk Alpha"
	elif $IS64BIT && ! $IS64BITONLY; then
		echo "[*] copy $ARCH32 files to $BINDIR"
		cp $BASEDIR/lib/$ARCH32/lib*32.so $BINDIR 2>/dev/null
	fi	
	
	cd $BINDIR
		for file in lib*.so; do mv "$file" "${file:3:${#file}-6}"; done		
	cd $BASEDIR
	echo "[-] copy all $ABI files from $BINDIR to $BASEDIR"
	cp $BINDIR/* $BASEDIR 2>/dev/null
	
	if [ -e $ASSETSDIR/stub.apk ]; then
 		echo "[-] copy 'stub.apk' from $ASSETSDIR to $BASEDIR"
 		cp $ASSETSDIR/stub.apk $BASEDIR 2>/dev/null
 		STUBAPK=true
 	fi
	
	chmod -R 755 $BASEDIR
	export STUBAPK
}

# This code block seems to be responsible for detecting the device's architecture, API level, and Android version, and setting the corresponding variables. It doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
api_level_arch_detect() {
	echo "[-] Api Level Arch Detect"
	# Detect version and architecture
	# To select the right files for the patching

	ABI=$(getprop ro.product.cpu.abi)
	ABILIST32=$(getprop ro.product.cpu.abilist32)
	ABILIST64=$(getprop ro.product.cpu.abilist64)
		
	API=$(getprop ro.build.version.sdk)
	FIRSTAPI=$(getprop ro.product.first_api_level)
	
	AVERSION=$(getprop ro.build.version.release)	
	
	IS64BIT=false
	IS64BITONLY=false
	IS32BITONLY=false
	
	if [ "$ABI" = "x86" ]; then
		ARCH=x86
		ARCH32=x86
	elif [ "$ABI" = "arm64-v8a" ]; then
		ARCH=arm64
		ARCH32=armeabi-v7a
		IS64BIT=true
	elif [ "$ABI" = "x86_64" ]; then
		ARCH=x64
		ARCH32=x86
		IS64BIT=true
	else
		ARCH=arm
		ABI=armeabi-v7a
		ABI32=armeabi-v7a
		IS64BIT=false
	fi

	if [ -z "$ABILIST32" ]; then 
		IS64BITONLY=true
	fi
	
	if [ -z "$ABILIST64" ]; then
		IS32BITONLY=true
	fi
	
	if $IS64BITONLY || $IS32BITONLY ; then
		echo "[-] Device Platform is $ARCH only"
	else	
		echo "[-] Device Platform: $ARCH"
		echo "[-] ARCH32 $ARCH32"
	fi

	echo "[-] Device SDK API: $API"	
	echo "[-] First API Level: $FIRSTAPI"
	echo "[-] The AVD runs on Android $AVERSION"
	
	[ -d /system/lib64 ] && IS64BIT=true || IS64BIT=false
	
	export ARCH
  	export ARCH32
	export IS64BIT
	export IS64BITONLY
	export IS32BITONLY
	export ABI
	export API
	export FIRSTAPI
	export AVERSION
}

# This code block provides a mechanism to abort the script when necessary. It doesn't contain any malicious code and simply exits the script when invoked.
abort_script() {
	echo "[!] aborting the script"
	exit
}

# This code block is used to determine the compression method of a file based on its first 8 bytes. It checks if the first 8 bytes match specific patterns for the LZ4 or Gzip compression methods and sets the ENDG variable accordingly. The value of ENDG indicates the file extension associated with the compression method (".lz4" for LZ4 or ".gz" for Gzip). This function doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
compression_method() {
	local FILE="$1"
	local FIRSTFILEBYTES
	local METHOD_LZ4="02214c18"
	local METHOD_GZ="1f8b0800"
	local ENDG=""
	FIRSTFILEBYTES=$(xxd -p -c8 -l8 "$FILE")
	FIRSTFILEBYTES="${FIRSTFILEBYTES:0:8}"

	if [ "$FIRSTFILEBYTES" == "$METHOD_LZ4" ]; then
		ENDG=".lz4"
	elif [ "$FIRSTFILEBYTES" == "$METHOD_GZ" ]; then
		ENDG=".gz"
	fi
	echo "$ENDG"
}

# This code block is used to detect the compression method used for a ramdisk image file (ramdisk.img). It checks the first 8 bytes of the file and determines if it matches the patterns for the LZ4 or Gzip compression methods. It then sets the appropriate variables (ENDG, METHOD, RAMDISK_LZ4, RAMDISK_GZ, and COMPRESS_SIGN) based on the detected compression method. If the compression method is unknown, the script is aborted. This function doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
detect_ramdisk_compression_method() {
	echo "[*] Detecting ramdisk.img compression"
	RDF=$BASEDIR/ramdisk.img
	CPIO=$BASEDIR/ramdisk.cpio
	CPIOORIG=$BASEDIR/ramdisk.cpio.orig

	local FIRSTFILEBYTES
	local METHOD_LZ4="02214c18"
	local METHOD_GZ="1f8b0800"
	COMPRESS_SIGN=""
	FIRSTFILEBYTES=$(xxd -p -c8 -l8 "$RDF")
	FIRSTFILEBYTES="${FIRSTFILEBYTES:0:8}"
	RAMDISK_LZ4=false
	RAMDISK_GZ=false
	ENDG=""
	METHOD=""

	if [ "$FIRSTFILEBYTES" == "$METHOD_LZ4" ]; then
		ENDG=".lz4"
		METHOD="lz4_legacy"
		RAMDISK_LZ4=true
		mv $RDF $RDF$ENDG
		RDF=$RDF$ENDG
		COMPRESS_SIGN="$METHOD_LZ4"
	elif [ "$FIRSTFILEBYTES" == "$METHOD_GZ" ]; then
		ENDG=".gz"
		METHOD="gzip"
		RAMDISK_GZ=true
		mv $RDF $RDF$ENDG
		#cp $RDF $RDF$ENDG
		COMPRESS_SIGN="$METHOD_GZ"
	fi

	if [ "$ENDG" == "" ]; then
		echo "[!] Ramdisk.img uses UNKNOWN compression $FIRSTFILEBYTES"
		abort_script
	fi

	echo "[!] Ramdisk.img uses $METHOD compression"
}

# This code block is used to run Magisk for installing or patching a fake boot image. It stops the target application, launches Magisk, prompts the user to install or patch a specific file ($FBI), and waits for the user to press Enter. The user's input is read with a timeout of 60 seconds. The code block itself doesn't contain any obvious malicious code, but its purpose and potential implications depend on the context in which it is used within the overall script or application.
runMagisk_to_Patch_fake_boot_img() {
	am force-stop $PKG_NAME
	echo "[-] Starting Magisk"
	monkey -p $PKG_NAME -c android.intent.category.LAUNCHER 1 > /dev/null 2>&1
	echo "[*] Install/Patch $FBI and hit Enter when done(max. 60s)"
	read -t 60 proceed
	case $proceed in
		*)
		;;
	esac
}

# This code block is used to detect the current user and switch to user 0 if the current user ID is different from 0. The specific purpose and implications of this user detection and switching depend on the context in which it is used within the overall script or application.
detecting_users() {
	local userID=""
	local userZero=0
	echo "[*] Detecting current user"
	userID=$(am get-current-user)
	echo "[-] Current user $userID"
	if [ "$userID" != "$userZero" ]; then
		echo "[-] Switching to user $userZero"
		am switch-user $userZero
		userID=$(am get-current-user)
		echo "[-] Current user $userID"
	fi
}

# This code block generates a build.prop file by extracting system properties using getprop and modifies it using sed. It also generates a recovery.fstab file by copying from an existing file. Finally, it adds the build.prop and recovery.fstab files to a stock ramdisk using magiskboot. The purpose and implications of these operations depend on the specific context in which this function is used within the overall script or application.
generate_build_prop() {
	echo "[*] generating Build.prop"
	local BPR=$BASEDIR/build.prop
	local recfstab=$BASEDIR/recovery.fstab
	getprop > $BPR
	sed -i -e 's/: /=/g' -e 's/\[//g' -e 's/\]//g' $BPR
	
	echo "[*] generating recovery.fstab from fstab.ranchu"
	cp /system/vendor/etc/fstab.ranchu $recfstab
	
	echo "[-] adding Build.prop and recovery.fstab to Stock Ramdisk"
	$BASEDIR/magiskboot cpio $CPIO \
		"add 0644 system/build.prop build.prop" \
		"add 0644 system/etc/recovery.fstab recovery.fstab"
	#exit
	#BASEDIR=$(pwd)
}

# This code block is responsible for creating a fake boot image by generating a minimal header and repacking the ramdisk image. It also involves invoking various functions related to installing Magisk, detecting users, and running Magisk to patch the fake boot image. The purpose and implications of these operations depend on the specific context in which this function is used within the overall script or application.
create_fake_boot_img() {
	echo "[*] Creating a fake Boot.img"
	FBHI=$BASEDIR/fakebootheader.img
	FBI=$SDCARD/fakeboot.img
	
	echo "[-] removing old $FBI"
	rm -f $FBI $RDF
	
	printf "\x41\x4E\x44\x52\x4F\x49\x44\x21" > $FBHI # ANDROID!
	printf "\x00\x00\x00\x00\x00\x00\x00\x00" >> $FBHI
	printf "\x00\x00\x00\x00\x00\x00\x00\x00" >> $FBHI
	printf "\x00\x00\x00\x00\x00\x00\x00\x00" >> $FBHI 
	printf "\x00\x00\x00\x00\x00\x08\x00\x00" >> $FBHI # 00080000 (Pagesize 2048)
	echo "[!] Only a minimal header is required for Magisk to repack the ramdisk"
	#mv $RDF $CPIO
	if $DEBUG; then
		generate_build_prop
	fi
	
	echo "[*] repacking ramdisk.img into $FBI"
	$BASEDIR/magiskboot repack $FBHI $FBI > /dev/null 2>&1
	InstallMagiskTemporarily	
	detecting_users
	runMagisk_to_Patch_fake_boot_img
	RemoveTemporarilyMagisk
}

# This function is responsible for unpacking the patched ramdisk from a previously created fake boot image. It searches for the latest magisk_patched file in the specified directory, unpacks the ramdisk using magiskboot, and then deletes all the magisk_patched files.
unpack_patched_ramdisk_from_fake_boot_img() {

	if [ "$MagiskPatchedFiles" != "" ]; then
		echo "[!] magisk_patched file(s) could be found!"
		for file in `ls -tu $SDCARD/*magisk_patched*`; do
			MagiskPatched=$file
			break
		done
		echo "[*] unpacking latest $MagiskPatched"
		$BASEDIR/magiskboot unpack $MagiskPatched > /dev/null 2>&1
		echo "[-] deleting all magisk_patched files"
		for file in `ls -tu $SDCARD/*magisk_patched*`; do
			rm -f $file
		done
	else
		echo "[!] No magisk_patched file could be found!"
		abort_script
	fi
}

# This function is responsible for processing the fake boot image. It checks if there are external magisk_patched files available and unpacks the ramdisk from the latest file. If no external files are found, it creates a fake boot image, checks for magisk_patched files again, and unpacks the ramdisk if found.
process_fake_boot_img() {
	
	SDCARD=/sdcard/Download
	
	echo "[*] Processing fake Boot.img"
	MagiskPatchedFiles=$(ls "$SDCARD"/*magisk_patched*) > /dev/null 2>&1
	if [ "$MagiskPatchedFiles" != "" ]; then
		echo "[!] external magisk_patched file(s) could be found!"
		unpack_patched_ramdisk_from_fake_boot_img
	else
		create_fake_boot_img
		MagiskPatchedFiles=$(ls "$SDCARD"/*magisk_patched*) > /dev/null 2>&1
		unpack_patched_ramdisk_from_fake_boot_img
	fi
}

# This function is responsible for constructing the environment required for the script. If the script is running as root, it sets up the necessary directories and files, changes permissions, and reboots the system. If the script is not running as root, it displays an error message and suggests verifying root access.
# requires additional setup
# EnvFixTask
construct_environment() {
	ROOT=`su -c "id -u"` 2>/dev/null

	if [[ "$ROOT" == "" ]]; then
		ROOT=$(id -u)
	fi

	echo "[-] Constructing environment - PAY ATTENTION to the AVDs Screen"
	if [[ $ROOT -eq 0 ]]; then
		echo "[!] we are root"
		local BBBIN=$BB
		local COMMONDIR=$BASEDIR/assets
		local NVBASE=/data/adb
		local MAGISKBIN=$NVBASE/magisk

		`su -c "rm -rf $MAGISKBIN/* 2>/dev/null && \
				mkdir -p $MAGISKBIN 2>/dev/null && \
				cp -af $BINDIR/. $COMMONDIR/. $BBBIN $MAGISKBIN && \
				chown root.root -R $MAGISKBIN && \
				chmod -R 755 $MAGISKBIN && \
				rm -rf $BASEDIR 2>/dev/null && \
				reboot \
				"`
	fi

	echo "[!] not root yet"
	echo "[!] Couldn't construct environment"
	echo "[!] Double Check Root Access"
	echo "[!] Re-Run Script with clean ramdisk.img and try again"
	abort_script
}

# The function can be used to validate a file's existence, readability, size, writability, and regularity.
checkfile() {
	#echo "checkfile $1"
	if [ -r "$1" ]; then
		#echo "File exists and is readable"
		if [ -s "$1" ]; then
			#echo "and has a size greater than zero"
			if [ -w "$1" ]; then
				#echo "and is writable"
				if [ -f "$1" ]; then
					#echo "and is a regular file."
					return 1
				fi
			fi
		fi
	fi
	return 0
}

# The function allows for the installation of multiple APK files in the Apps folder, and it handles the scenario where an incompatible version of an app is already installed.
# If all is done well so far, you can install some APK's to the AVD
# every APK file in the Apps DIR will be (re)installed
# Like magisk.apk etc.
install_apps() {
	local ADBECHO=""
  	APPS="Apps/*"
	echo "[-] Install all APKs placed in the Apps folder"
	FILES=$APPS

	for f in $FILES; do
		echo "[*] Trying to install $f"
		ADBECHO=""
		while [[ "$ADBECHO" != *"Success"* ]]; do
			ADBECHO=$(adb install -r -d "$f" 2>&1)
			if [[ "$ADBECHO" == *"INSTALL_FAILED_UPDATE_INCOMPATIBLE"* ]]; then
				echo "$ADBECHO" | while read I; do echo "[*] $I"; done
				Package=
				for I in $ADBECHO; do			
					if [[ "$Package" == *"Package"* ]]; then
						echo "[*] Need to uninstall $I first"				
						ADBECHO=$(adb uninstall $I 2>&1)
						echo "$ADBECHO" | while read I; do echo "[*] $I"; done
						ADBECHO=$(adb install -r -d "$f" 2>&1)					
						break
					fi
					Package=$I
				done
			fi	
		done
		echo "$ADBECHO" | while read I; do echo "[*] $I"; done
	done
}

# The function ensures that a backup file is only created if it doesn't already exist. This helps prevent overwriting existing backup files and allows for preserving the original file state before making any modifications.
create_backup() {
	local FILE=""
	local FILEPATH=""
	local FILENAME=""
	local BACKUPFILE=""
	FILE="$1"
	FILEPATH=${FILE%/*}
	FILENAME=${FILE##*/}	
	BACKUPFILE="$FILENAME.backup"
	# If no backup file exist, create one
	if ( checkfile $FILEPATH/$BACKUPFILE -eq 0 ); then
		echo "[*] create Backup File of $FILENAME"
		cp $FILEPATH/$FILENAME $FILEPATH/$BACKUPFILE
		#ls -l $($FILEPATH/$FILENAME)
	else
		echo "[-] $FILENAME Backup exists already"
	fi
}

# The function is designed to simplify the process of pushing files from the local machine to the AVD using the adb tool.
pushtoAVD() {
	local SRC=""
	local DST="$2"
	local ADBPUSHECHO=""
	SRC=${1##*/}
		
	if [[ "$DST" == "" ]]; then
		echo "[*] Push $SRC into $ADBBASEDIR"
		ADBPUSHECHO=$(adb push $1 $ADBBASEDIR 2>/dev/null)
	else
		echo "[*] Push $SRC into $ADBBASEDIR/$DST"
		ADBPUSHECHO=$(adb push $1 $ADBBASEDIR/$DST 2>/dev/null)
	fi
	
	echo "[-] $ADBPUSHECHO"
}

# The function simplifies the process of pulling files from the AVD to the local machine using the adb tool.
pullfromAVD() {
	local SRC=""
	local DST=""
	local ADBPULLECHO=""
	SRC=${1##*/}
	DST=${2##*/}
	ADBPULLECHO=$(adb pull $ADBBASEDIR/$SRC $2 2>/dev/null)
	if [[ ! "$ADBPULLECHO" == *"error"* ]]; then
		echo "[*] Pull $SRC into $DST"
  		echo "[-] $ADBPULLECHO"
	fi
}

# The function simplifies the process of restoring backed-up files by automatically iterating through the backup files in a directory and replacing the corresponding original files with their backups.
restore_backups() {
	local BACKUPFILE=""
	local RESTOREFILE=""
	for f in $1/*.backup; do
    	BACKUPFILE="$f"
    	RESTOREFILE="${BACKUPFILE%.backup}"
    	echo "[!] Restoring ${BACKUPFILE##*/} to ${RESTOREFILE##*/}"
    	cp $BACKUPFILE $RESTOREFILE
	done
	echo "[*] Backups still remain in place"
	exit 0
}


# The function provides a convenient way to switch between the original and patched versions of the ramdisk file by renaming the files accordingly.
toggle_Ramdisk() {

	#AVDPATHWITHRDFFILE="$1"
	#AVDPATH=${AVDPATHWITHRDFFILE%/*}
	#RDFFILE=${AVDPATHWITHRDFFILE##*/}
	#RESTOREPATH=$AVDPATH
	
	local RamdiskFile="$AVDPATHWITHRDFFILE"
	local PatchedFile="$AVDPATHWITHRDFFILE.patched"
	local BackupFile="$AVDPATHWITHRDFFILE.backup"
	
	local hasBackup=false
	local hasPatched=false
	
	if ( checkfile $BackupFile -eq 0 ); then
		echo "[!] we need a valid backup file to proceed"
		exit 0
	fi

	echo "[-] Toggle Ramdisk"
	if ( checkfile $PatchedFile -eq 0 ); then
		echo "[*] Pushing patched Ramdisk into Stack"
		mv $RamdiskFile $PatchedFile
		echo "[*] Popping original Ramdisk from Backup"
		cp $BackupFile $RamdiskFile
	else
		echo "[*] Popping patched Ramdisk back from Stack"
		mv -f $PatchedFile $RamdiskFile 
	fi
	exit 0
}

# The function helps ensure that ADB is properly set up and functional before proceeding with further operations.
TestADB() {
	local HOME=~/
	local ADB_DIR_M=Library/Android/sdk/platform-tools
	local ADB_DIR_L=Android/Sdk/platform-tools
	local ADB_DIR=""
	local ADB_EX=""

	echo "[-] Test if ADB SHELL is working"
	
	ADBWORKS=$(which adb)
	if [ "$ADBWORKS" == *"not found"* ] || [ "$ADBWORKS" == "" ]; then
		if [ -d "$HOME$ADB_DIR_M" ]; then
			ADB_DIR=$ADB_DIR_M
		elif [ -d "$HOME$ADB_DIR_L" ]; then
			ADB_DIR=$ADB_DIR_L
		else
			echo "[!] ADB not found, please install and add it to your \$PATH"
			exit
		fi
		
		cd $HOME > /dev/null
			for adb in $(find $ADB_DIR -type f -name adb); do
				ADB_EX="~/$adb"
			done
		cd - > /dev/null

		if [[ $ADB_EX == "" ]]; then
			echo "[!] ADB binary not found in ~/$ADB_DIR"
			exit
		fi
		
  		echo "[!] ADB is not in your Path, try to"
  		echo "export PATH=~/$ADB_DIR:\$PATH"
  		echo ""
  		exit
	fi

	ADBWORKS=$(adb shell 'echo true' 2>/dev/null)
	if [ -z "$ADBWORKS" ]; then
		echo "no ADB connection possible"
		exit
	fi
}

# The purpose of this function is to make BlueStacks writable by changing the type of the Root.vdi file from "Readonly" to "Normal" in the AVBox configuration.
MakeBlueStacksRW() {

	if ( checkfile $BLUESTACKSPATH/$AVBOXFILE -eq 0 ); then
		echo "[!] $AVBOXFILE not found"
		echo "[!] check your BlueStacks installation"
		exit 0	
	fi
	echo "[!] $AVBOXFILE found"
	create_backup $AVBOX
	echo "[*] Changing $ROOTVDIFILE type to \"Normal\""
	sed 's,location="Root.vdi" format="VDI" type="Readonly",location="Root.vdi" format="VDI" type="Normal",' $AVBOX > $AVBOX".edit" 
	mv $AVBOX".edit" $AVBOX
}

# The purpose of this function is to initiate the shut down and reboot process for the AVD or BlueStacks, and it provides instructions and information related to rooting and using Magisk with the respective environments.
ShutDownAVD() {
	
	if ( "$BLUESTACKS" ); then
		echo "[-] Shut-Down & Reboot BlueStacks and see if it worked"
		echo "[-] Root and Su with Magisk for BlueStacks"
		
		APPNAME=BlueStacks.app	
		if [ $(ps aux | grep -v grep | grep -c $APPNAME) -gt 0 ]; then
			echo "[-] Trying to shut down BlueStacks"
			pkill -x BlueStacks
			if [ "$?" == "0" ]; then
				echo "[*] Shut down Signal were send"
			fi
			echo "[!] If BlueStacks doesn't shut down, try it manually!"
		fi
		echo "[*] If BlueStacks Home Screen is closing, run Magisk from the Terminal and hide it"
		echo "adb shell monkey -p com.topjohnwu.magisk -c android.intent.category.LAUNCHER 1"
	else
		echo "[-] Shut-Down & Reboot (Cold Boot Now) the AVD and see if it worked"
		echo "[-] Root and Su with Magisk for Android Studio AVDs"
		
		ADBPULLECHO=$(adb shell setprop sys.powerctl shutdown 2>/dev/null)
		if [[ ! "$ADBPULLECHO" == *"error"* ]]; then
			echo "[-] Trying to shut down the AVD"
		fi
		echo "[!] If the AVD doesn't shut down, try it manually!"		
	fi
	echo "[-] Modded by NewBit XDA - Jan. 2021"
	echo "[!] Huge Credits and big Thanks to topjohnwu, shakalaca, vvb2060 and HuskyDG"
}

# This function primarily focuses on copying Magisk-related files to the AVD or BlueStacks environment, executing the rootAVD.sh script, and performing additional operations based on the specified flags and conditions.
CopyMagiskToAVD() {
	# Set Folders and FileNames	
	echo "[*] Set Directorys"
	if ( "$BLUESTACKS" ); then
		# BlueStacks has its ramdisk.img within, no AVD Path needed
		# but the VBOX container Root.vdi should be backuped		
		BLUESTACKSROOTVDIFILE=~/Library/BlueStacks/Android/Root.vdi
		AVBOX=~/Library/BlueStacks/Android/Android.vbox
		AVBOXFILE=${AVBOX##*/}
		BLUESTACKSPATH=${BLUESTACKSROOTVDIFILE%/*}
		ROOTVDIFILE=${BLUESTACKSROOTVDIFILE##*/}
		RESTOREPATH=$BLUESTACKSPATH
	else			
		AVDPATHWITHRDFFILE="$1"
		AVDPATH=${AVDPATHWITHRDFFILE%/*}
		RDFFILE=${AVDPATHWITHRDFFILE##*/}
		RESTOREPATH=$AVDPATH
	fi
	
	if ( "$restore" ); then
		restore_backups $RESTOREPATH
	fi
	
	if ( "$toggleRamdisk" ); then
		toggle_Ramdisk $RESTOREPATH
	fi
	
	if ( "$BLUESTACKS" ); then
		if ( checkfile $BLUESTACKSPATH/$ROOTVDIFILE -eq 0 ); then
			echo "[!] $ROOTVDIFILE not found"
			echo "[!] check your BlueStacks installation"
			exit		
		fi
		echo "[!] $ROOTVDIFILE found"
		create_backup $BLUESTACKSROOTVDIFILE
		MakeBlueStacksRW
	fi
	TestADB

	# The Folder where the script was called from
	ROOTAVD="`getdir "${BASH_SOURCE:-$0}"`"
	MAGISKZIP=$ROOTAVD/Magisk.zip

	# change to ROOTAVD directory
	cd $ROOTAVD

	# Kernel Names
	BZFILE=$ROOTAVD/bzImage
	KRFILE=kernel-ranchu

	if ( "$InstallApps" ); then
		install_apps
		exit
	fi

	ADBWORKDIR=/data/data/com.android.shell
	adb shell "cd $ADBWORKDIR" 2>/dev/null
	
	if [ "$?" != "0" ]; then
		echo "[!] $ADBWORKDIR doesn't exist, switching to tmp'"
		ADBWORKDIR=/data/local/tmp
	fi
	 
	ADBBASEDIR=$ADBWORKDIR/Magisk
	echo "[-] In any AVD via ADB, you can execute code without root in $ADBWORKDIR"

	echo "[*] Cleaning up the ADB working space"
	adb shell rm -rf $ADBBASEDIR

	echo "[*] Creating the ADB working space"
	adb shell mkdir $ADBBASEDIR
	
	# If Magisk.zip file doesn't exist, just ignore it
	if ( ! checkfile $MAGISKZIP -eq 0 ); then
		echo "[-] Magisk installer Zip exists already"
		pushtoAVD $MAGISKZIP
	fi

	# Proceed with ramdisk
	if "$RAMDISKIMG"; then
		# Is it a ramdisk named img file?
		if [[ "$RDFFILE" != ramdisk*.img ]]; then
			echo "[!] please give a path to a ramdisk file"
			exit
		fi

		create_backup $AVDPATHWITHRDFFILE
		pushtoAVD $AVDPATHWITHRDFFILE "ramdisk.img"

		if ( "$InstallKernelModules" ); then
			INITRAMFS=$ROOTAVD/initramfs.img
			if ( ! checkfile $INITRAMFS -eq 0 ); then
				pushtoAVD $INITRAMFS
			fi
		fi

		if ( "$AddRCscripts" ); then
			for f in $ROOTAVD/*.rc; do
				pushtoAVD $f
			done
			pushtoAVD $ROOTAVD/sbin
		fi
	fi

	pushtoAVD "rootAVD.sh"
	
	if ( "$UpdateBusyBoxScript" ); then
		pushtoAVD "libbusybox*.so"	
	fi
	
	echo "[-] run the actually Boot/Ramdisk/Kernel Image Patch Script"
	echo "[*] from Magisk by topjohnwu and modded by NewBit XDA"

	adb shell sh $ADBBASEDIR/rootAVD.sh $@
	if [ "$?" == "0" ]; then

		if ( "$UpdateBusyBoxScript" ); then
			pullfromAVD "bbscript.sh" "rootAVD.sh"
			chmod +x rootAVD.sh
			exit	
		fi
		
		if ( ! "$DEBUG" && "$BLUESTACKS" ); then
			pullfromAVD "Magisk.apk" "Apps/"
			pullfromAVD "Magisk.zip" $ROOTAVD
			echo "[-] Clean up the ADB working space"
			adb shell rm -rf $ADBBASEDIR
			install_apps
			ShutDownAVD
			adb kill-server
		fi
				
		# In Debug-Mode we can skip parts of the script
		if ( ! "$DEBUG" && "$RAMDISKIMG" ); then

			pullfromAVD "ramdiskpatched4AVD.img" $AVDPATHWITHRDFFILE
			pullfromAVD "Magisk.apk" "Apps/"
			pullfromAVD "Magisk.zip" $ROOTAVD

			if ( "$InstallPrebuiltKernelModules" ); then
				pullfromAVD $BZFILE $ROOTAVD
				InstallKernelModules=true
			fi

			if ( "$InstallKernelModules" ); then
				if ( ! checkfile $BZFILE -eq 0 ); then
					create_backup $AVDPATH/$KRFILE
					echo "[*] Copy $BZFILE (Kernel) into kernel-ranchu"
					cp $BZFILE $AVDPATH/$KRFILE
					if [ "$?" == "0" ]; then
						rm -f $BZFILE $INITRAMFS
					fi
				fi
			fi

			echo "[-] Clean up the ADB working space"
			adb shell rm -rf $ADBBASEDIR

			install_apps
			ShutDownAVD
		fi
	fi
}

###################################################
# Method to extract specified field data from json
# Globals: None
# Arguments: 2
#   ${1} - value of field to fetch from json
#   ${2} - Optional, nth number of value from extracted values, by default shows all.
# Input: file | here string | pipe
#   _json_value "Arguments" < file
#   _json_value "Arguments <<< "${varibale}"
#   echo something | _json_value "Arguments"
# Result: print extracted value
###################################################
# This function is used to extract a specified field value from a JSON string or file.
# Note: The function assumes that the variable $BB contains the path to the grep, sed, and awk binaries, which are typically used in BusyBox.
json_value() {
    $BB grep -o "\"""${1}""\"\:.*" | $BB sed -e "s/.*\"""${1}""\": //" -e 's/[",]*$//' -e 's/["]*$//' -e 's/[,]*$//' -e "s/\"//" -n -e "${2}"p
}

# This function is used to check the internet connection status of an AVD (Android Virtual Device).
# Note: The function assumes that the variable $BB contains the path to the timeout and wget binaries, which are typically used in BusyBox.
CheckAVDIsOnline() {	
	if [ -z $AVDIsOnline ]; then
		echo "[-] Checking AVDs Internet connection..."
		AVDIsOnline=false
		$BB timeout 3 $BB wget -q --spider --no-check-certificate http://github.com > /dev/null 2>&1
		if [ $? -eq 0 ]; then
    		AVDIsOnline=true
		fi
		$AVDIsOnline && echo "[!] AVD is online" || echo "[!] AVD is offline"
	fi
	export AVDIsOnline
}

# This function is used to format a version string in a pretty way.
# Note: The function assumes that the variable $BB contains the path to the grep binary, which is typically used in BusyBox.
GetPrettyVer() {
		if echo $1 | $BB grep -q '\.'; then
			PRETTY_VER=$1
		else
			PRETTY_VER="$1($2)"
		fi
		echo "$PRETTY_VER"
}

# This function is used to download a file from a specified URL.
# Note: The function assumes that the variable $BASEDIR contains the base directory path, and the variable $BB contains the path to the wget and dd binaries, which are typically used in BusyBox.
DownLoadFile() {
	CheckAVDIsOnline
	if ("$AVDIsOnline"); then
		local URL="$1"
		local SRC="$2"
		local DST="$3"

		OF=$BASEDIR/download.tmp
		rm -f $OF
		BS=1024
		CUTOFF=100

		if [ "$DST" == "" ]; then
			DST=$BASEDIR/$SRC
		else
			DST=$BASEDIR/$DST
		fi
		#echo "[*] Downloading File $SRC"
		$BB wget -q -O $DST --no-check-certificate $URL$SRC
		RESULT="$?"
		while [ $RESULT != "0" ]
		do
			echo "[!] Error while downloading File $SRC"
			echo "[-] patching it together"
			FSIZE=$(./busybox stat $DST -c %s)
			if [ $FSIZE -gt $BS ]; then
				COUNT=$(( FSIZE/BS ))
				if [ $COUNT -gt $CUTOFF ]; then
					COUNT=$(( COUNT - $CUTOFF ))
				fi
			fi
			$BB dd if=$DST count=$COUNT bs=$BS of=$OF > /dev/null 2>&1
			mv -f $OF $DST
			$BB wget -q -O $DST --no-check-certificate $URL$SRC -c
			RESULT="$?"
		done
		echo "[!] Downloading File $SRC complete!"
	fi
}

# This function is used to download the USB Host Permissions Module zip file if it is not already present.
# Note: The function assumes that the variable $BB contains the path to the wget binary, which is typically used in BusyBox.
GetUSBHPmod() {
	USBHPZSDDL="/sdcard/Download/usbhostpermissons.zip"
	USBHPZ="https://github.com/newbit1/usbhostpermissons/releases/download/v1.0/usbhostpermissons.zip"
	if [ ! -e $USBHPZSDDL ]; then
		echo "[*] Downloading USB HOST Permissions Module Zip"
		$BB wget -q -O $USBHPZSDDL --no-check-certificate $USBHPZ
	else
		echo "[*] USB HOST Permissions Module Zip is already present"
	fi
}

# This function is used to fetch and process data from a JSON file related to Magisk downloads.
# Note: The function assumes that the $BB variable contains the path to the wget binary, which is typically used in BusyBox.
FetchMagiskDLData() {
	local SRCURL="$1"
	local CHANNEL="$2"
	local JSON="$CHANNEL.json"
	local VER=""
	local VER_CODE=""
	local DLL=""
	local i=1
	
	rm -rf *.json > /dev/null 2>&1
	$BB wget -q --no-check-certificate $SRCURL$JSON
	
	VER=$(json_value "version" < $JSON)
	VER_CODE=$(json_value "versionCode" 1 < $JSON)
	DLL=$(json_value "link" 1 < $JSON)
	VER=$(GetPrettyVer $VER $VER_CODE)

	if ! echo $DLL | $BB grep -q 'https'; then
		DLL=$SRCURL$DLL
	fi
	
	if [ -e $MAGISK_DL_LINKS ]; then
		echo $DLL >> $MAGISK_DL_LINKS
		echo $VER >> $MAGISK_VERSIONS
		echo $CHANNEL >> $MAGISK_CHANNEL		
		i=$($BB sed -n '$=' $MAGISK_DL_LINKS)
		echo "[$i] $CHANNEL $VER" >> $MAGISK_MENU
	else
		if [[ "$MAGISK_LOCL_VER" != "" ]]; then
			echo "local" > $MAGISK_DL_LINKS
			echo $MAGISK_LOCL_VER > $MAGISK_VERSIONS
			echo "local "$CHANNEL > $MAGISK_CHANNEL
			echo "[$i] local $CHANNEL $MAGISK_LOCL_VER (ENTER)" > $MAGISK_MENU
			i=$((i+1))			
		fi
		echo $DLL >> $MAGISK_DL_LINKS
		echo $VER >> $MAGISK_VERSIONS
		echo $CHANNEL >> $MAGISK_CHANNEL		
		if [[ "$i" == "1" ]]; then
			
			echo "[$i] $CHANNEL $VER (ENTER)" >> $MAGISK_MENU
		else
			#echo $CHANNEL > $MAGISK_CHANNEL
			echo "[$i] $CHANNEL $VER" >> $MAGISK_MENU
		fi		
	fi
	rm -rf *.json > /dev/null 2>&1
}

# This function is used to fetch and process commit data related to Magisk releases.
# Note: The function assumes that the $BB variable contains the path to the wget binary, which is typically used in BusyBox.
FetchMagiskRLCommits() {
#$GITHUB $TJWCOMMITSURL $TJWBLOBURL $CHANNEL $TJWREPOURL
	local DOMAIN="$1"
	local COMMITSURL="$2"
	local BLOBURL="$3"
	local CHANNEL="$4"
	local JSON="$CHANNEL.json"
	local REPOURL="$5"
	local COMMITS=""
	
	rm -rf $JSON
	$BB wget -q --no-check-certificate $DOMAIN$COMMITSURL$JSON
	
	COMMITS=$($BB grep $BLOBURL $JSON | $BB sed -e 's,.*'"$BLOBURL"',,' -e 's,'"$JSON"'.*,,')

	for commit in $COMMITS;do
		FetchMagiskDLData $RAWGITHUB$REPOURL$commit $CHANNEL
	done
}

# This function is used to check and choose available Magisk versions for installation.
# Note: The function assumes that the $BB variable contains the path to the wget binary, which is typically used in BusyBox.
CheckAvailableMagisks() {

	MAGISK_VERSIONS=$BASEDIR/magisk_versions.txt
	MAGISK_DL_LINKS=$BASEDIR/magisk_dl_links.txt
	MAGISK_MENU=$BASEDIR/magisk_menu.txt
	MAGISK_CHANNEL=$BASEDIR/magisk_channel.txt
	
	local GITHUB="https://github.com/"
	RAWGITHUB="https://raw.githubusercontent.com/"
	local TJWREPOURL="topjohnwu/magisk-files/"	
	local TJWCOMMITSURL="topjohnwu/magisk-files/commits/master/"
	local TJWBLOBURL="topjohnwu/magisk-files/blob/"
	
	local VVB2060REPOURL="vvb2060/magisk_files/"
	local VVB2060COMMITSURL="vvb2060/magisk_files/commits/alpha/"
	local VVB2060BLOBURL="vvb2060/magisk_files/blob/"
	local DLL_cnt=0

	if [ -z $MAGISKVERCHOOSEN ]; then

		UFSH=$BASEDIR/assets/util_functions.sh
		OF=$BASEDIR/download.tmp
		BS=1024
		CUTOFF=100
		
		if [ -e $UFSH ]; then
			MAGISK_LOCL_VER=$($BB grep $UFSH -e "MAGISK_VER" -w | sed 's/^.*=//')
			MAGISK_LOCL_VER_CODE=$($BB grep $UFSH -e "MAGISK_VER_CODE" -w | sed 's/^.*=//')
			MAGISK_LOCL_VER=$(GetPrettyVer $MAGISK_LOCL_VER $MAGISK_LOCL_VER_CODE)		
		else
			MAGISK_LOCL_VER=""
			MAGISK_LOCL_VER_CODE=""
		fi

		CheckAVDIsOnline
		if ("$AVDIsOnline"); then
			echo "[!] Checking available Magisk Versions"

			rm *.txt > /dev/null 2>&1
			
			FetchMagiskDLData $RAWGITHUB$TJWREPOURL"master/" "stable"
			FetchMagiskDLData $RAWGITHUB$TJWREPOURL"master/" "canary"
			FetchMagiskDLData $RAWGITHUB$VVB2060REPOURL"alpha/" "alpha"
			
			while :
			do
				DLL_cnt=$($BB sed -n '$=' $MAGISK_DL_LINKS)
				echo "[?] Choose a Magisk Version to install and make it local"
				echo "[s] (s)how all available Magisk Versions"
				cat $MAGISK_MENU
				read -t 10 choice		
				case $choice in
					*)
						if [[ "$choice" == "" ]]; then
							choice=1
						fi

						if [[ $choice -gt 0 && $choice -le $DLL_cnt ]]; then
							MAGISK_VER=$($BB sed "$choice"'!d' $MAGISK_VERSIONS)
							MAGISK_CNL=$($BB sed "$choice"'!d' $MAGISK_CHANNEL)
							echo "[-] You choose Magisk $MAGISK_CNL Version $MAGISK_VER"
							
							MAGISK_DL=$($BB sed "$choice"'!d' $MAGISK_DL_LINKS)
							if [[ "$MAGISK_DL" == "local" ]]; then
								MAGISKVERCHOOSEN=false
							fi							
							break
						fi
						
						if [[ "$choice" == "s" ]]; then
							echo "[!] Fetching all available Magisk Versions..."
							rm *.txt > /dev/null 2>&1
							FetchMagiskRLCommits $GITHUB $TJWCOMMITSURL $TJWBLOBURL "stable" $TJWREPOURL
							FetchMagiskRLCommits $GITHUB $TJWCOMMITSURL $TJWBLOBURL "canary" $TJWREPOURL
							FetchMagiskRLCommits $GITHUB $VVB2060COMMITSURL $VVB2060BLOBURL "alpha" $VVB2060REPOURL
						else
							echo "invalid option $choice"
						fi
						;;
 				esac
			done
			#exit
		else
			MAGISK_VER=$MAGISK_LOCL_VER
			MAGISKVERCHOOSEN=false
		fi

		if [ -z $MAGISKVERCHOOSEN ]; then
			echo "[*] Deleting local Magisk $MAGISK_LOCL_VER"
			rm -rf $MZ
			rm -rf *.apk
			echo "[*] Downloading Magisk $MAGISK_CNL $MAGISK_VER"
			$BB wget -q -O $MZ --no-check-certificate $MAGISK_DL
			RESULT="$?"
			while [ $RESULT != "0" ]; do
				echo "[!] Error while downloading Magisk $MAGISK_CNL $MAGISK_VER"
				echo "[-] patching it together"
				FSIZE=$(./busybox stat $MZ -c %s)
				if [ $FSIZE -gt $BS ]; then
					COUNT=$(( FSIZE/BS ))
					if [ $COUNT -gt $CUTOFF ]; then
						COUNT=$(( COUNT - $CUTOFF ))
					fi
				fi
				$BB dd if=$MZ count=$COUNT bs=$BS of=$OF > /dev/null 2>&1
				mv -f $OF $MZ
				$BB wget -q -O $MZ --no-check-certificate $MAGISK_DL -c
				RESULT="$?"
			done
			echo "[!] Downloading Magisk $MAGISK_CNL $MAGISK_VER complete!"
			MAGISKVERCHOOSEN=true
			PrepBusyBoxAndMagisk
		fi

		# Call rootAVD with GetUSBHPmodZ to download the usbhostpermissons module
		$GetUSBHPmodZ && $AVDIsOnline && GetUSBHPmod
	fi
	export MAGISK_VER
	export MAGISKVERCHOOSEN
}

# This function is used to install Magisk on the device temporarily
InstallMagiskTemporarily() {
	PKG_NAMES=$(pm list packages magisk | cut -f 2 -d ":") > /dev/null 2>&1
	PKG_NAME=""
	echo "[!] Temporarily installing Magisk"
	
	for PKG_NAME in $PKG_NAMES; do
		pm clear $PKG_NAME >/dev/null 2>&1
		pm uninstall $PKG_NAME >/dev/null 2>&1
	done	

	pm install -r $MZ >/dev/null 2>&1
	PKG_NAME=$(pm list packages magisk | cut -f 2 -d ":") > /dev/null 2>&1	
}

# This function is used to remove Magisk from the device
RemoveTemporarilyMagisk() {
	echo "[!] Removing Temporarily installed Magisk"
	pm clear $PKG_NAME >/dev/null 2>&1
	pm uninstall $PKG_NAME >/dev/null 2>&1
}

# This function is used to search for a working BusyBox version on the device
FindWorkingBusyBox() {
	echo "[*] Finding a working Busybox Version"
	local bbversion=""
	
# 	for file in $(ls $BASEDIR/lib/*/*busybox*); do
# 		echo "[*] Extracting Magisk.zip ..."
# 		$file unzip $MZ -oq
# 		break
# 	done

	for file in $(ls $BASEDIR/lib/$ABI/*busybox*); do
		chmod +x "$file"	
		bbversion=$($file | $file head -n 1)>/dev/null 2>&1
		if [[ $bbversion == *"BusyBox"*"Magisk"*"multi-call"* ]]; then
			echo "[!] Found a working Busybox Version"
			echo "[!] $bbversion"
			export WorkingBusyBox="$file"
			break
		fi
	done
}

# This function is used to extract Magisk library files from the temporarily installed Magisk package
ExtractMagiskViaPM() {
	InstallMagiskTemporarily
	PKG_PATH=$(pm path $PKG_NAME)
	PKG_PATH=${PKG_PATH%/*}
	PKG_PATH=${PKG_PATH#*:}
	echo "[*] Copy Magisk Lib Files to workdir"
	cp -Rf $PKG_PATH/lib $BASEDIR/
	RemoveTemporarilyMagisk
}

# This function is used to download the up-to-date version of the script from a specified URL.
DownloadUptoDateSript() {
	echo "[*] Trying to Download the Up-To-Date Script Version"
	
	local DLL_URL="https://raw.githubusercontent.com/cygnus-xr1/rootAVD/master/"
	local DLL_SCRIPT="rootAVD.sh"
	local DLL_ROOTAVD_ZIP="https://github.com/cygnus-xr1/rootAVD/archive/refs/heads/master.zip"
	local PKG_PATH=""
	
	ExtractMagiskViaPM
	FindWorkingBusyBox
	CopyBusyBox	
	DownLoadFile $DLL_URL $DLL_SCRIPT
}

# This function is used to extract the Busybox binary from the script itself.
ExtractBusyboxFromScript() {
	local BBSCR=$BASEDIR/bbscript.sh
	local bblineoffset=""
	local last_line=""
	local bbline_cnt=""
	cp $0 $BBSCR

	bblineoffset=$(sed -n '/BUSYBOXBINARY/=' $BBSCR | sort -nr)
	bbline_cnt=$(sed -n '/BUSYBOXBINARY/=' $BBSCR | sort -nr | sed -n '$=')

	if [[ "$bbline_cnt" -gt "3" ]]; then	
		echo "[*] Extracting busybox from script ..."
		for i in $bblineoffset;do
			cp $BBSCR busybox
			sed -i 1,"$i"'d',"$i"'q' $BB
			$($BB >/dev/null 2>&1)
			if [[ "$?" == "0" ]]; then
				echo "[!] Found a working busybox Binary: $file"
				echo "[!] $($BB | $BB head -n 1)"
				break
			fi
		done
	fi
	
	$($BB >/dev/null 2>&1)
	if [[ ! "$?" == "0" ]]; then
		echo "[!] There is no busybox behind the script"
		#echo "[!] Run rootAVD with UpdateBusyBoxScript first"
		DownloadUptoDateSript	
	fi
}

# This function is used to update the Busybox binary in the script.
UpdateBusyBoxToScript() {
	local BBSCR=$BASEDIR/bbscript.sh
	local FSIZE=""
	local last_line=""
	cp $0 $BBSCR
	chmod +x libbusybox*.so
	
	# Find the first working busybox binary
	for file in libbusybox*.so; do 
		cp -fF $file $BB
		$($BB >/dev/null 2>&1)
		if [[ "$?" == "0" ]]; then
			echo "[!] Found a working busybox Binary: $file"
			echo "[!] $($BB | $BB head -n 1)"
			break	
		fi
	done
	
	$($BB >/dev/null 2>&1)
	if [[ ! "$?" == "0" ]]; then
		echo "[!] Can't find a working busybox Binary"
		exit 0		
	fi
		
	# Add every provided busybox binary behind the script
	for file in libbusybox*.so; do 
		echo "" >> $BBSCR
		echo "###BUSYBOXBINARY###" >> $BBSCR
		FSIZE=$(./busybox stat $BBSCR -c %s)
		$BB dd if=$file oflag=seek_bytes seek=$FSIZE of=$BBSCR > /dev/null 2>&1
	done

	#sed -i "$((bblineoffset+1))","$last_line"'d' $BBSCR
}

# This function is responsible for copying the Busybox binary from the "lib" directory to the working directory.
CopyBusyBox() {
	echo "[*] Copy busybox from lib to workdir"
# 	if [ -e $BASEDIR/lib ]; then
# 		chmod -R 755 $BASEDIR/lib
# 		cp -f $BASEDIR/lib/$ABI/libbusybox.so $BB >/dev/null 2>&1	
# 		$BB >/dev/null 2>&1 && return || cp -f $BASEDIR/lib/$ARCH32/libbusybox.so $BB >/dev/null 2>&1
# 		$BB >/dev/null 2>&1 && return || cp -f $BASEDIR/lib/$ARCH/libbusybox.so $BB >/dev/null 2>&1
# 	fi
	cp -fF $WorkingBusyBox $BB >/dev/null 2>&1
	chmod +x $BB
}

# This function is responsible for moving the Busybox binary from the "lib" directory to the working directory.
MoveBusyBox() {
	echo "[*] Move busybox from lib to workdir"
# 	if [ -e $BASEDIR/lib ]; then
# 		chmod -R 755 $BASEDIR/lib
# 		mv -f $BASEDIR/lib/$ABI/libbusybox.so $BB >/dev/null 2>&1	
# 		$BB >/dev/null 2>&1 && return || mv -f $BASEDIR/lib/$ARCH32/libbusybox.so $BB >/dev/null 2>&1
# 		$BB >/dev/null 2>&1 && return || mv -f $BASEDIR/lib/$ARCH/libbusybox.so $BB >/dev/null 2>&1
# 	fi
	mv -f $WorkingBusyBox $BB >/dev/null 2>&1
	chmod +x $BB
}

# This function is responsible for locating an unzip binary and extracting the contents of Magisk.zip.
FindUnzip() {
	local RESULT=""
	if [ -e $MZ ]; then
		echo "[*] Looking for an unzip binary"
		$(which unzip > /dev/null 2>&1)
		RESULT="$?"
		
		if [[ "$RESULT" == "0" ]]; then
			echo "[-] unzip binary found"	
			echo "[*] Extracting busybox and Magisk.zip via unzip ..."
			$(unzip $MZ -oq > /dev/null 2>&1)
			RESULT="$?"
			if [[ "$RESULT" != "0" ]]; then
				echo "[!] unzip binary does not support extracting Magisk.zip"
				exit 1
			else
				FindWorkingBusyBox	
			fi			
		else
			echo "[-] No unzip binary found"
		fi
		
		if [[ "$RESULT" != "0" ]]; then
			ExtractMagiskViaPM
			FindWorkingBusyBox
			CopyBusyBox			
			echo "[*] Extracting Magisk.zip via Busybox ..."
			$($BB unzip $MZ -oq > /dev/null 2>&1)		
			RESULT="$?"
			if [[ "$RESULT" != "0" ]]; then
				echo "[!] Busybox binary does not support extracting Magisk.zip"
				exit 1
			fi	
		fi
	else
		echo "[!] No Magisk.zip present"
		exit 1
	fi
}

# This function prepares the environment for executing the script by setting up the necessary files and directories.
PrepBusyBoxAndMagisk() {
	echo "[-] Switch to the location of the script file"
	BASEDIR="`getdir "${BASH_SOURCE:-$0}"`"
	if [[ "$BASEDIR" == "." ]]; then
		BASEDIR=$(pwd)
	fi
	TMP=$BASEDIR/tmp
	BB=$BASEDIR/busybox
	MZ=$BASEDIR/Magisk.zip
	cd $BASEDIR
	
	if ("$UpdateBusyBoxScript"); then
		UpdateBusyBoxToScript $@
		exit 1	
	fi
	
	rm -rf lib assets
	FindUnzip		
	MoveBusyBox	
	
	chmod -R 755 $BASEDIR	
	CheckAvailableMagisks
}

# This function is responsible for re-running the script in a Magisk Busybox standalone (D)ASH environment.
ExecBusyBoxAsh() {
	export PREPBBMAGISK=1
	export ASH_STANDALONE=1
	export BASEDIR
	export TMP
	export BB
	export MZ
		
	if [ "$DERIVATE" == "BlueStacks" ]; then
		CheckBlueStacksSUBinary
		echo "[*] Re-Run rootAVD in Magisk Busybox STANDALONE (D)ASH as Root"
		exec $SU 0 $BB sh $0 $@	
	fi
	echo "[*] Re-Run rootAVD in Magisk Busybox STANDALONE (D)ASH"
	exec $BB sh $0 $@
}

# This function is used to repack the ramdisk.
repack_ramdisk() {
	echo "[*] Repacking ramdisk .."
	cd $TMP/ramdisk > /dev/null
		`find . | cpio -H newc -o > $CPIO`
	cd - > /dev/null
}

# This function is used to extract the patched ramdisk.
extract_patched_ramdisk() {
echo "[-] Clearing $TMP/ramdisk"
rm -fR $TMP/ramdisk
mkdir -p $TMP/ramdisk

cd $TMP/ramdisk > /dev/null
	$BASEDIR/busybox cpio -F $CPIO -i *lib* > /dev/null 2>&1
	../../magiskboot cpio ../../ramdisk.cpio "rm -r /lib/modules/*"
	ls -la
cd - > /dev/null
exit
}

# This function is used to extract the stock ramdisk.
extract_stock_ramdisk() {
echo "[-] Clearing $TMP/ramdisk"
rm -fR $TMP/ramdisk
mkdir -p $TMP/ramdisk

cd $TMP/ramdisk > /dev/null
	echo "[*] Extracting Stock ramdisk"
	$BASEDIR/busybox cpio -F $CPIO -i > /dev/null 2>&1
cd - > /dev/null
}

# This function is used to decompress the ramdisk.img file.
decompress_ramdisk(){
	echo "[-] taken from shakalaca's MagiskOnEmulator/process.sh"
	echo "[*] executing ramdisk splitting / extraction / repacking"
	# extract and check ramdisk
	if [[ $API -ge 30 ]]; then
		$RAMDISK_GZ && gzip -fdk $RDF$ENDG
		echo "[-] API level greater then 30"
		echo "[*] Check if we need to repack ramdisk before patching .."
		COUNT=`strings -t d $RDF | grep TRAILER\!\! | wc -l`
	  if [[ $COUNT -gt 1 ]]; then
		echo "[-] Multiple cpio archives detected"
		REPACKRAMDISK=1
	  fi
	fi	
	
	if [ "$DERIVATE" == "BlueStacks" ]; then
		$RAMDISK_GZ && gzip -fdk $RDF$ENDG
		COUNT=`strings -t d $RDF | grep TRAILER | wc -l`
		REPACKRAMDISK=1
	fi	
	
	if [[ -n "$REPACKRAMDISK" ]]; then
		$RAMDISK_GZ && rm $RDF$ENDG
	  	echo "[*] Unpacking ramdisk .."
	  	mkdir -p $TMP/ramdisk
	  	LASTINDEX=0
	  	NextArchiveINDEX=0
	  	IBS=1
	  	OBS=4096
	  	OF=$TMP/temp$ENDG
		
	  	RAMDISKS=`strings -t d $RDF | grep TRAILER | sed 's|TRAILER.*|TRAILER|'`	  	

	  	for OFFSET in $RAMDISKS; do
	  		
			# calculate offset to next archive
			if [ `echo "$OFFSET" | grep TRAILER` ]; then
				# find position of end of TRAILER!!! string in image

				if $RAMDISK_GZ; then
					LEN=${#OFFSET}
					START=$((LASTINDEX+LEN))
					# find first occurance of string in image, that will be start of cpio archive
					dd if=$RDF skip=$START count=$OBS ibs=$IBS obs=$OBS of=$OF > /dev/null 2>&1
					HEAD=`strings -t d $OF | head -1`
					# vola
					for i in $HEAD;do
						HEAD=$i
						break
					done
					LASTINDEX=$((START+HEAD))
				fi	
		  		continue
			fi

			# number of blocks we'll extract
			$RAMDISK_GZ && BLOCKS=$(((OFFSET+128)/IBS))
			if $RAMDISK_LZ4; then
				if [ $LASTINDEX == "0" ]; then
					echo "[*] Searching for the real End of the 1st Archive"				
					while [ $LASTINDEX == "0" ]; do
						FIRSTFILEBYTES=$(xxd -p -c8 -l8 -s "$OFFSET" "$RDF")
						FIRSTFILEBYTES="${FIRSTFILEBYTES:0:8}"
						if [ "$FIRSTFILEBYTES" == "$COMPRESS_SIGN" ]; then
							break		
						fi		
						OFFSET=$((OFFSET+1))
					done
				fi
				BLOCKS=$((OFFSET/IBS))
			fi

			# extract and dump
			echo "[-] Dumping from $LASTINDEX to $BLOCKS .."
			dd if=$RDF skip=$LASTINDEX count=$BLOCKS ibs=$IBS obs=$OBS of=$OF > /dev/null 2>&1
					
			cd $TMP/ramdisk > /dev/null
				$RAMDISK_GZ && cat $OF | $BASEDIR/busybox cpio -i > /dev/null 2>&1
				if $RAMDISK_LZ4; then	
					$BASEDIR/magiskboot decompress $OF $OF.cpio
					$BASEDIR/busybox cpio -F $OF.cpio -i > /dev/null 2>&1
				fi
			cd - > /dev/null

			LASTINDEX=$OFFSET
	  	done	  	
		repack_ramdisk
	else
		echo "[*] After decompressing ramdisk.img, magiskboot will work"
		$RAMDISK_GZ && RDF=$RDF$ENDG
		$BASEDIR/magiskboot decompress $RDF $CPIO
	fi
	#update_lib_modules
}

# This function is used to apply various modifications to the ramdisk image.
apply_ramdisk_hacks() {

	# Call rootAVD with PATCHFSTAB if you want the RAMDISK merge your modded fstab.ranchu before Magisk Mirror gets mounted

	# cp the read-only fstab.ranchu from vendor partition and add usb:auto for SD devices
	# kernel musst have Mass-Storage + SCSI Support enabled to create /dev/block/sd* nodes

	#echo "[!] PATCHFSTAB=$PATCHFSTAB"
	if ("$PATCHFSTAB"); then
		echo "[-] pulling fstab.ranchu from AVD"
		cp /system/vendor/etc/fstab.ranchu $(pwd)
		echo "[-] adding usb:auto to fstab.ranchu"
		echo "/devices/*/block/sd* auto auto defaults voldmanaged=usb:auto" >> fstab.ranchu
		#echo "/devices/*/block/loop7 auto auto defaults voldmanaged=sdcard:auto" >> fstab.ranchu
		#echo "/devices/1-* auto auto defaults voldmanaged=usb:auto" >> fstab.ranchu
		$BASEDIR/magiskboot cpio ramdisk.cpio \
		"mkdir 0755 overlay.d/vendor" \
		"mkdir 0755 overlay.d/vendor/etc" \
		"add 0644 overlay.d/vendor/etc/fstab.ranchu fstab.ranchu"
		echo "[-] overlay adding complete"
		#echo "[-] jumping back to patching ramdisk for magisk init"
	#else
		#echo "[!] Skipping fstab.ranchu patch with /dev/block/sda"
		#echo "[?] If you want fstab.ranchu patched, Call rootAVD with PATCHFSTAB"
	fi

	#echo "[!] AddRCscripts=$AddRCscripts"
	if ("$AddRCscripts"); then
		echo "[*] adding *.rc files to ramdisk"
		#for f in *.rc; do
		#	./magiskboot cpio ramdisk.cpio "add 0644 overlay.d/sbin/$f $f"
		#done
		#CSTRC=init.custom.rc
		#touch $CSTRC
		for f in *.rc; do
			#echo "$f" > $CSTRC
			$BASEDIR/magiskboot cpio ramdisk.cpio "add 0755 overlay.d/$f $f"
		done
		
		if [ -d $BASEDIR/sbin ]; then
			echo "[*] adding sbin files to ramdisk"
			for f in sbin/*; do
			$BASEDIR/magiskboot cpio ramdisk.cpio "add 0755 overlay.d/$f $f"
			done		
		fi
		#$BASEDIR/magiskboot cpio ramdisk.cpio "add 0755 overlay.d/$CSTRC $CSTRC"		
		echo "[-] overlay adding complete"
		#echo "[-] jumping back to patching ramdisk for magisk init"
	#else
		#echo "[!] Skip adding *.rc scripts into ramdisk.img/sbin/*.rc"
		#echo "[?] If you want *.rc scripts added into ramdisk.img/sbin/*.rc, Call rootAVD with AddRCscripts"
	fi

	#$PATCHFSTAB && SKIPOVERLAYD="#" || SKIPOVERLAYD=""
	update_lib_modules
}

# This function is used to verify the origin of the boot image's ramdisk by comparing the kernel release number of the Android Virtual Device (AVD) with the kernel release number extracted from the ramdisk.
verify_ramdisk_origin() {
	echo "[*] Verifying Boot Image by its Kernel Release number:"
	local KRNAVD=$(uname -r)
	local KRNRDF=""
	echo "[-] This AVD = $KRNAVD"
	KRNRDF=$(cat $CPIO | strings | grep -m 1 vermagic= | sed 's/vermagic=//;s/ .*$//')
	
	if [ "$KRNRDF" != "" ]; then
		echo "[-]  Ramdisk = $KRNRDF"
		if [ "$KRNAVD" == "$KRNRDF" ]; then
			echo "[!] Ramdisk is probably from this AVD"
		else
			echo "[!] Ramdisk is probably NOT from this AVD"
		fi
	fi
}

# This function is used to test the status of the ramdisk patching on the boot image.
test_ramdisk_patch_status(){

	if [ -e ramdisk.cpio ]; then
		$BASEDIR/magiskboot cpio ramdisk.cpio test 2>/dev/null
		STATUS=$?
		echo "[-] Checking ramdisk STATUS=$STATUS"
	else
		echo "[-] Stock A only system-as-root"
		STATUS=0
	fi
	PATCHEDBOOTIMAGE=false

	case $((STATUS & 3)) in
	  0 )  # Stock boot
		echo "[-] Stock boot image detected"
		SHA1=`$BASEDIR/magiskboot sha1 ramdisk.cpio 2>/dev/null`
		cp -af $CPIO $CPIOORIG 2>/dev/null
		;;

	  1 )  # Magisk patched
		echo "[-] Magisk patched boot image detected"
		#construct_environment
		PATCHEDBOOTIMAGE=true
		;;
	  2 )  # Unsupported
		echo "[!] Boot image patched by unsupported programs"
		echo "[!] Please restore back to stock boot image"
		abort_script
		;;
	esac

	if [ $((STATUS & 8)) -ne 0 ]; then
	  echo "[!] TWOSTAGE INIT image detected - Possibly using 2SI, export env var"
	  export TWOSTAGEINIT=true
	fi
	export PATCHEDBOOTIMAGE
}

# This function performs various patches and modifications to the ramdisk.
patching_ramdisk(){
	##########################################################################################
	# Ramdisk patches
	##########################################################################################

	echo "[-] Patching ramdisk"

	echo "KEEPVERITY=$KEEPVERITY" > config
	echo "KEEPFORCEENCRYPT=$KEEPFORCEENCRYPT" >> config
	echo "RECOVERYMODE=$RECOVERYMODE" >> config

	# actually here is the SHA of the bootimage generated
	# we only have one file, so it could make sense
	[ ! -z $SHA1 ] && echo "SHA1=$SHA1" >> config
	
	# Compress to save precious ramdisk space
	
	if $IS32BITONLY || ! $IS64BITONLY ; then
		$BASEDIR/magiskboot compress=xz magisk32 magisk32.xz
	fi

	if $IS64BITONLY || ! $IS32BITONLY ; then
		$BASEDIR/magiskboot compress=xz magisk64 magisk64.xz
	fi

	$IS64BITONLY && SKIP32="#" || SKIP32=""
	$IS64BIT && SKIP64="" || SKIP64="#"
	
	if $STUBAPK; then
		echo "[!] stub.apk is present, compress and add it to ramdisk"
		$BASEDIR/magiskboot compress=xz stub.apk stub.xz
	fi
	
	$STUBAPK && SKIPSTUB="" || SKIPSTUB="#"

	# Here gets the ramdisk.img patched with the magisk su files and stuff
	
	echo "[*] adding overlay.d/sbin folders to ramdisk"
	$BASEDIR/magiskboot cpio ramdisk.cpio \
	"mkdir 0750 overlay.d" \
	"mkdir 0750 overlay.d/sbin"
	
	apply_ramdisk_hacks

	echo "[!] patching the ramdisk with Magisk Init"
	$BASEDIR/magiskboot cpio ramdisk.cpio \
	"add 0750 init magiskinit" \
	"$SKIP32 add 0644 overlay.d/sbin/magisk32.xz magisk32.xz" \
	"$SKIP64 add 0644 overlay.d/sbin/magisk64.xz magisk64.xz" \
	"$SKIPSTUB add 0644 overlay.d/sbin/stub.xz stub.xz" \
	"patch" \
	"backup ramdisk.cpio.orig" \
	"mkdir 000 .backup" \
	"add 000 .backup/.magisk config"
}

# This function is responsible for renaming or copying the "Magisk.zip" file to "Magisk.apk" based on the value of the MAGISKVERCHOOSEN variable.
rename_copy_magisk() {
	if ( "$MAGISKVERCHOOSEN" ); then
		echo "[!] Copy Magisk.zip to Magisk.apk"
		cp Magisk.zip Magisk.apk
	else
		echo "[!] Rename Magisk.zip to Magisk.apk"
		mv Magisk.zip Magisk.apk
	fi
}

# This function is responsible for compressing and repacking the modified ramdisk into the "ramdiskpatched4AVD.img" format.
repacking_ramdisk(){
	if [ $((STATUS & 4)) -ne 0 ]; then
		echo "[!] Compressing ramdisk before repacking it"
	  $BASEDIR/magiskboot cpio ramdisk.cpio compress
	fi

	echo "[*] repacking back to ramdisk.img format"
	# Rename and compress ramdisk.cpio back to ramdiskpatched4AVD.img
	$BASEDIR/magiskboot compress=$METHOD "ramdisk.cpio" "ramdiskpatched4AVD.img"
}

# Strips HTML links from the specified file by using the sed command.
strip_html_links() {
	sed -i -e 's/<a href=/\n<a href=/g;s/<\/a>/<\/a>\n/g' "$1"
}

# Filters out lines containing the string ">Update kernel to builds" from the specified file using the sed command and the -n option with the /pattern/p syntax.
strip_kernel_builds() {
	sed -i -n '/>Update kernel to builds/p' "$1"
}

# Filters out lines containing the string ">Next" from the specified file using the sed command and the -n option with the /pattern/p syntax.
strip_next_pages() {
	sed -n '/>Next/p' "$1"
}

# This function is used to find and retrieve the next pages of a website by following the "Next" links.
find_next_pages() {
	local URL="$2"
	local NEXTPAGESRC=""
	local TMPHTML="tmp.html"
	rm -rf $TMPHTML
	NEXTPAGESRC=$(strip_next_pages $1)
	
	echo "[-] Find Next Page(s)"
	while [[ "$NEXTPAGESRC" != "" ]]; do				
		NEXTPAGESRC=$(echo $NEXTPAGESRC | sed -e 's/.*href=\"/\1/' -e 's/\">Next.*//')
		#echo $NEXTPAGESRC
		DownLoadFile $URL $NEXTPAGESRC $TMPHTML
		strip_html_links $TMPHTML
		cat $TMPHTML >> $1
		NEXTPAGESRC=$(strip_next_pages $TMPHTML)					
	done
}
# This function handles the update of prebuilt kernel modules by fetching the latest versions, allowing the user to choose a version, downloading the necessary files, and installing them into the ramdisk. The function also performs checks and adjustments for different scenarios, such as patched or stock ramdisks.
update_lib_modules() {
	local INITRAMFS=initramfs.img
	if ("$AVDIsOnline"); then
		if ( "$InstallPrebuiltKernelModules" ); then
			local KERNEL_ARCH="x86-64"
			if [[ $ABI == *"arm"* ]]; then
  				KERNEL_ARCH="arm64"
			fi
			local unameR=$(uname -r)
			local majmin=${unameR%.*}
			#majmin=5.15
			local installedbuild=${unameR##*ab}
			
			echo "[*] Fetching Kernel Data:"
			echo "[-]              Android: $AVERSION"
			echo "[-]                 Arch: $KERNEL_ARCH"
			echo "[-]                Uname: $unameR"
			echo "[-]              Version: $majmin"
			echo "[-]        Build Version: $installedbuild"
			
			local URL="https://android.googlesource.com"
			#local TAG="android$AVERSION-mainline-sdkext-release"
			local TAG="android$AVERSION-gsi"
			#local TAG="master"
			local KERSRC="/kernel/prebuilts/$majmin/$KERNEL_ARCH/+log/refs/heads/$TAG"
			#local KERSRC="/platform/prebuilts/qemu-kernel/+log/refs/heads/$TAG"
			#https://android.googlesource.com/platform/prebuilts/qemu-kernel/+log/refs/heads/android11-gsi
			#https://android.googlesource.com/platform/prebuilts/qemu-kernel/+/refs/heads/android11-gsi
			#local KERSRC="/kernel/prebuilts/$majmin/$KERNEL_ARCH/+log/refs/heads/android$AVERSION-mainline-sdkext-release"

			local MODSRC="/kernel/prebuilts/common-modules/virtual-device/$majmin/$KERNEL_ARCH/+log/refs/heads/$TAG"
			#local MODSRC="/kernel/prebuilts/common-modules/virtual-device/$majmin/$KERNEL_ARCH/+log/refs/heads/android$AVERSION-mainline-sdkext-release"
			local KERPREMASHTML="kernelprebuiltsmaster.html"
			local KERDST="prebuiltkernel.tar.gz"
			local MODDST="prebuiltmodules.tar.gz"
			local MODPREMASHTML="moduleprebuiltsmaster.html"
			local TMPSTRIPFILE="tmpstripfile"
			local TMPREADFILE="tmpreadfile"
			local FILETOREAD=""
			local FILETOSTRIP=""

			local BUILDVERCHOOSEN=""
			local CHOOSENLINE=""
			local KERCOMMITID=""
			local MODCOMMITID=""

			local ker_line_cnt=""
			local mod_line_cnt=""
			local i=""
			

			DownLoadFile $URL $KERSRC $KERPREMASHTML
			strip_html_links $KERPREMASHTML			
			find_next_pages $KERPREMASHTML $URL			
			strip_kernel_builds $KERPREMASHTML
			
			DownLoadFile $URL $MODSRC $MODPREMASHTML			
			strip_html_links $MODPREMASHTML
			find_next_pages $MODPREMASHTML $URL	
			strip_kernel_builds $MODPREMASHTML

			ker_line_cnt=$(sed -n '$=' $KERPREMASHTML)
			mod_line_cnt=$(sed -n '$=' $MODPREMASHTML)

			if [ "$ker_line_cnt" -gt "$mod_line_cnt" ];then
				FILETOREAD="$KERPREMASHTML"
				FILETOSTRIP="$MODPREMASHTML"
			else
				FILETOREAD="$MODPREMASHTML"
				FILETOSTRIP="$KERPREMASHTML"
			fi

			touch $TMPSTRIPFILE
			touch $TMPREADFILE

			echo "[*] Find common Build Versions"
			while read line; do
				BUILDVER=$(echo $line | sed -e 's/<[^>]*>//g')
				grep -e ">$BUILDVER<" -F $FILETOSTRIP >> $TMPSTRIPFILE
				if [[ "$?" == "0" ]]; then
					echo $line >> $TMPREADFILE
				fi
			done < $FILETOREAD

			mv -f $TMPREADFILE $FILETOREAD
			mv -f $TMPSTRIPFILE $FILETOSTRIP

			while :
			do
				i=0
				echo "[!] Installed Kernel builds $installedbuild"
				echo "[?] Choose a Prebuild Kernel/Module Version"
				while read line; do
					i=$(( i + 1 ))
					BUILDVER=$(echo $line | sed -e 's/<[^>]*>//g')
					echo "[$i] $BUILDVER"
				done < $KERPREMASHTML

				read choice
				case $choice in
					*)
						if [[ "$choice" == "" ]]; then
							choice=1
						fi
						if [ "$choice" -le "$i" ];then
							BUILDVERCHOOSEN=$choice
							CHOOSENLINE=$(sed -n "$BUILDVERCHOOSEN"'p' $KERPREMASHTML)
							BUILDVER=$(echo $CHOOSENLINE| sed -e 's/<[^>]*>//g')
							KERCOMMITID=$(echo $CHOOSENLINE | sed -e 's/^[^"]*"\([^"]*\)".*/\1/')
							KERCOMMITID=${KERCOMMITID##*/}".tar.gz"

							CHOOSENLINE=$(sed -n "$BUILDVERCHOOSEN"'p' $MODPREMASHTML)
							MODCOMMITID=$(echo $CHOOSENLINE | sed -e 's/^[^"]*"\([^"]*\)".*/\1/')
							MODCOMMITID=${MODCOMMITID##*/}".tar.gz"

							echo "[$BUILDVERCHOOSEN] You choose: $BUILDVER"
							break
						fi
						echo "Choice is out of range";;
				esac
			done

			echo "[-] Downloading Kernel and its Modules..."
			# Download Kernel
			DownLoadFile "$URL/kernel/prebuilts/$majmin/$KERNEL_ARCH/+archive/" $KERCOMMITID $KERDST
			# Download Modules
			DownLoadFile "$URL/kernel/prebuilts/common-modules/virtual-device/$majmin/$KERNEL_ARCH/+archive/" $MODCOMMITID $MODDST

			echo "[*] Extracting kernel-$majmin to bzImage"
			tar -xf $KERDST kernel-$majmin -O > bzImage
			echo "[-] Extracting $INITRAMFS"
			tar -xf $MODDST $INITRAMFS

			InstallKernelModules=true
		fi
	fi

	if ( "$InstallKernelModules" ); then

		if [ -e "$INITRAMFS" ]; then
			echo "[!] Installing new Kernel Modules"
			echo "[*] Copy initramfs.img $TMP/initramfs"
			mkdir -p $TMP/initramfs
			CMPRMTH=$(compression_method $INITRAMFS)
			cp $INITRAMFS $TMP/initramfs/initramfs.cpio$CMPRMTH
		else
			return 0
		fi

		echo "[-] Extracting Modules from $INITRAMFS"
		
		cd $TMP/initramfs > /dev/null
			$BASEDIR/magiskboot decompress initramfs.cpio$CMPRMTH
			$BASEDIR/busybox cpio -F initramfs.cpio -i *lib* > /dev/null 2>&1
		cd - > /dev/null

		if [ ! -d "$TMP/initramfs/lib/modules" ]; then
			echo "[!] $INITRAMFS has no lib/modules, aborting"
			rm -rf bzImage 2>/dev/null
			return 0
		fi
		
		# If Stock or patched Status
		if $PATCHEDBOOTIMAGE; then
			# If it is a already patched ramdisk
			if [ ! -e "$TMP/ramdisk" ]; then
				mkdir -p $TMP/ramdisk
			fi
			
			echo "[*] Extracting Modules from patched ramdisk.img"
			cd $TMP/ramdisk > /dev/null
				$BASEDIR/busybox cpio -F $CPIO -i *lib* > /dev/null 2>&1
			cd - > /dev/null
		else
			# If it is a Stock Ramdisk
			echo "[*] Extracting Modules from Stock ramdisk.img"
			extract_stock_ramdisk
		fi
				
		OLDVERMAGIC=$(cat $(find $TMP/ramdisk/. -name '*.ko' | head -n 1 2> /dev/null) | strings | grep vermagic= | sed 's/vermagic=//;s/ .*$//' 2> /dev/null)
		OLDANDROID=$(cat $(find $TMP/ramdisk/. -name '*.ko' | head -n 1 2> /dev/null) | strings | grep 'Android (' | sed 's/ c.*$//' 2> /dev/null)
		
		# If Stock or patched Status
		if $PATCHEDBOOTIMAGE; then
			# If it is a already patched ramdisk
			echo "[*] Removing Modules from patched ramdisk.img"
			$BASEDIR/magiskboot cpio $CPIO "rm -r lib" > /dev/null 2>&1
		else
			# If it is a Stock Ramdisk
			echo "[*] Removing Modules from Stock ramdisk.img"
			rm -f $TMP/ramdisk/lib/modules/*
		fi
		
		echo "[!] $OLDVERMAGIC"
		echo "[!] $OLDANDROID"
		
		echo "[-] Installing new Modules into ramdisk.img"
		cd $TMP/initramfs > /dev/null
			find ./lib/modules -type f -name '*' -exec cp {} . \;
			find . -name '*.ko' -exec cp {} $TMP/ramdisk/lib/modules/ \;
			NEWVERMAGIC=$(cat $(find . -name '*.ko' | head -n 1 2> /dev/null) | strings | grep vermagic= | sed 's/vermagic=//;s/ .*$//' 2> /dev/null)
			NEWANDROID=$(cat $(find . -name '*.ko' | head -n 1 2> /dev/null) | strings | grep 'Android (' | sed 's/ c.*$//' 2> /dev/null)
			cp modules.alias modules.dep modules.load modules.softdep $TMP/ramdisk/lib/modules/
		cd - > /dev/null

		echo "[!] $NEWVERMAGIC"
		echo "[!] $NEWANDROID"

		echo "[*] Adjusting modules.load and modules.dep"
		cd $TMP/ramdisk/lib/modules > /dev/null
			sed -i -E 's~[^[:blank:]]+/~/lib/modules/~g' modules.load
			sort -s -o modules.load modules.load
			sed -i -E 's~[^[:blank:]]+/~/lib/modules/~g' modules.dep
			sort -s -o modules.dep modules.dep
		cd - > /dev/null

		# If Stock or patched Status
		if $PATCHEDBOOTIMAGE; then
			# If it is a already patched ramdisk
			echo "[*] Adding new Modules into patched ramdisk.img"
			cd $TMP/ramdisk/lib/modules > /dev/null
				$BASEDIR/magiskboot cpio $CPIO \
				"mkdir 0755 lib" \
				"mkdir 0755 lib/modules" > /dev/null 2>&1
				for f in *.*; do
					$BASEDIR/magiskboot cpio $CPIO \
					"add 0644 lib/modules/$f $f" > /dev/null 2>&1
					#echo "$f"
				done
			cd - > /dev/null
		else
			# If it is a Stock Ramdisk
			repack_ramdisk
		fi		
	fi
}

#### BlueStacks functions
### taken from HuskyDG script MagiskOnEmu libbash.so ->

# The function uses the RANDOM variable and string slicing to randomly select characters from the specified character set to build the random string. The random_pick variable holds the randomly generated index used for character selection.
random() {
	VALUE=$1; TYPE=$2; PICK="$3"; PICKC="$4"
	TMPR=""
	HEX="0123456789abcdef"; HEXC=16
	CHAR="qwertyuiopasdfghjklzxcvbnm"; CHARC=26
	NUM="0123456789"; NUMC=10
	COUNT=$(seq 1 1 $VALUE)
	list_pick=$HEX; C=$HEXC
	[ "$TYPE" == "char" ] &&  list_pick=$CHAR && C=$CHARC 
	[ "$TYPE" == "number" ] && list_pick=$NUM && C=$NUMC 
	[ "$TYPE" == "custom" ] && list_pick="$PICK" && C=$PICKC 
		  for i in $COUNT; do
			  random_pick=$(( $RANDOM % $C))
			  echo -n ${list_pick:$random_pick:1}
		  done
}

# The random_str() function generates a random string of variable length using a combination of alphanumeric characters.
random_str() {
	random_length=$(random 1 custom 56789 5);
	random $random_length custom "qwertyuiopasdfghjklzxcvbnm0123456789QWERTYUIOPASDFGHJKLZXCVBNM" 63 | base64 | sed "s/=//g"
}

# This function sets up the Magisk environment and loads the Magisk modules. It includes various commands to mount directories, clone folders, and configure Magisk-related services.
magisk_loader() {
	magisk_overlay=`random_str`
	magisk_postfsdata=`random_str`
	magisk_service=`random_str`
	magisk_daemon=`random_str`
	magisk_boot_complete=`random_str`
	magisk_loadpolicy=`random_str`
	dev_random=`random_str`
    #system-as-root, /sbin is removal
    MAGISKTMP="/dev/$dev_random"
    mount_sbin="mkdir -p \"$MAGISKTMP\"
mnt_tmpfs \"$MAGISKTMP\"
chmod 755 \"$MAGISKTMP\""
     umount_sbin="umount /sbin"


# apply multiple sepolicy at same time

LOAD_MODULES_POLICY="rm -rf \"\$MAGISKTMP/.magisk/sepolicy.rules\"
for module in \$(ls /data/adb/modules); do
              if ! [ -f \"/data/adb/modules/\$module/disable\" ] && [ -f \"/data/adb/modules/\$module/sepolicy.rule\" ]; then
                  echo \"## * module sepolicy: \$module\" >>\"\$MAGISKTMP/.magisk/sepolicy.rules\"
                  cat  \"/data/adb/modules/\$module/sepolicy.rule\" >>\"\$MAGISKTMP/.magisk/sepolicy.rules\"
                  echo \"\" >>\"\$MAGISKTMP/.magisk/sepolicy.rules\"
                  
              fi
          done
\$MAGISKTMP/magiskpolicy --live --apply \"\$MAGISKTMP/.magisk/sepolicy.rules\""

ADDITIONAL_SCRIPT="( # addition script
rm -rf /data/adb/post-fs-data.d/fix_mirror_mount.sh
rm -rf /data/adb/service.d/fix_modules_not_show.sh


# additional script to deal with bullshit faulty design of emulator
# that close built-in root will remove magisk's /system/bin/su

echo \"
export PATH=\\\"\$MAGISKTMP:\\\$PATH\\\"
if [ -f \\\"/system/bin/magisk\\\" ]; then
    umount -l /system/bin/su
    rm -rf /system/bin/su
    ln -fs ./magisk /system/bin/su
    mount -o ro,remount /system/bin
    umount -l /system/bin/magisk
    mount --bind \\\"\$MAGISKTMP/magisk\\\" /system/bin/magisk
fi\" >\$MAGISKTMP/emu/magisksu_survival.sh

# additional script to deal with bullshit faulty design of Bluestacks
# that /system is a bind mountpoint

echo \"
SCRIPT=\\\"\\\$0\\\"
MAGISKTMP=\\\$(magisk --path) || MAGISKTMP=/sbin
( #fix bluestacks
MIRROR_SYSTEM=\\\"\\\$MAGISKTMP/.magisk/mirror/system\\\"
test ! -d \\\"\\\$MIRROR_SYSTEM/android/system\\\" && exit
test \\\"\\\$(cd /system; ls)\\\" == \\\"\\\$(cd \\\"\\\$MIRROR_SYSTEM\\\"; ls)\\\" && exit
mount --bind \\\"\\\$MIRROR_SYSTEM/android/system\\\" \\\"\\\$MIRROR_SYSTEM\\\" )
( #fix mount data mirror
function cmdline() { 
	awk -F\\\"\\\${1}=\\\" '{print \\\$2}' < /proc/cmdline | cut -d' ' -f1 2> /dev/null
}

# additional script to deal with bullshit faulty design of Android-x86
# that data is a bind mount from $SRC/data on ext4 partition


SRC=\\\"\\\$(cmdline SRC)\\\"
test -z \\\"\\\$SRC\\\" && exit
LIST_TEST=\\\"
/data
/data/adb
/data/adb/magisk
/data/adb/modules
\\\"
count=0
for folder in \\\$LIST_TEST; do
test \\\"\\\$(ls -A \\\$MAGISKTMP/.magisk/mirror/\\\$folder 2>/dev/null)\\\" == \\\"\\\$(ls -A \\\$folder 2>/dev/null)\\\" && count=\\\$((\\\$count + 1))
done
test \\\"\\\$count\\\" == 4 && exit
count=0
for folder in \\\$LIST_TEST; do
test \\\"\\\$(ls -A \\\$MAGISKTMP/.magisk/mirror/data/\\\$SRC/\\\$folder 2>/dev/null)\\\" == \\\"\\\$(ls -A \\\$folder 2>/dev/null)\\\" && count=\\\$((\\\$count + 1))
done
if [ \\\"\\\$count\\\" == 4 ]; then
mount --bind \\\"\\\$MAGISKTMP/.magisk/mirror/data/\\\$SRC/data\\\" \\\"\\\$MAGISKTMP/.magisk/mirror/data\\\"
fi )
rm -rf \\\"\\\$SCRIPT\\\"
\" >/data/adb/post-fs-data.d/fix_mirror_mount.sh
echo \"
SCRIPT=\\\"\\\$0\\\"
MAGISKTMP=\\\$(magisk --path) || MAGISKTMP=/sbin
CHECK=\\\"/data/adb/modules/.mk_\\\$RANDOM\\\$RANDOM\\\"
touch \\\"\\\$CHECK\\\"
test \\\"\\\$(ls -A \\\$MAGISKTMP/.magisk/modules 2>/dev/null)\\\" != \\\"\\\$(ls -A /data/adb/modules 2>/dev/null)\\\" && mount --bind \\\$MAGISKTMP/.magisk/mirror/data/adb/modules \\\$MAGISKTMP/.magisk/modules
rm -rf \\\"\\\$CHECK\\\"
rm -rf \\\"\\\$SCRIPT\\\"\" >/data/adb/service.d/fix_modules_not_show.sh
chmod 755 /data/adb/service.d/fix_modules_not_show.sh
chmod 755 /data/adb/post-fs-data.d/fix_mirror_mount.sh; )"


EXPORT_PATH="export PATH /sbin:/system/bin:/system/xbin:/vendor/bin:/apex/com.android.runtime/bin:/apex/com.android.art/bin"


magiskloader="

         on early-init
             $EXPORT_PATH
              

          on post-fs-data
$RM_RUSTY_MAGISK
              start logd
              start adbd
              rm /dev/.magisk_unblock
              exec u:r:su:s0 root root -- $MAGISKBASE/busybox sh -o standalone $MAGISKBASE/overlay.sh
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk --daemon
              start $magisk_postfsdata
              # wait all magisk post-fs-data jobs are completed or 40s  has passed
              wait /dev/.magisk_unblock 40
              rm /dev/.magisk_unblock

          service $magisk_postfsdata $MAGISKTMP/magisk --post-fs-data
              user root
              seclabel u:r:magisk:s0
              oneshot

          service $magisk_service $MAGISKTMP/magisk --service
              class late_start
              user root
              seclabel u:r:magisk:s0
              oneshot

          on property:sys.boot_completed=1
              $umount_sbin
              start $magisk_boot_complete
# remove magisk service traces from some detection
# although detect modified init.rc is not always correct
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc.$magisk_postfsdata
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc.$magisk_service
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc.$magisk_boot_complete
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc_debug_pid.$magisk_postfsdata
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc_debug_pid.$magisk_service
              exec u:r:magisk:s0 root root -- $MAGISKTMP/magisk resetprop --delete init.svc_debug_pid.$magisk_boot_complete
              exec u:r:magisk:s0 root root -- $MAGISKTMP/busybox sh -o standalone $MAGISKTMP/emu/magisksu_survival.sh
          service $magisk_boot_complete $MAGISKTMP/magisk --boot-complete
              user root
              seclabel u:r:magisk:s0
              oneshot"


overlay_loader="#!$MAGISKBASE/busybox sh

export PATH=/sbin:/system/bin:/system/xbin


mnt_tmpfs(){ (
# MOUNT TMPFS ON A DIRECTORY
MOUNTPOINT=\"\$1\"
mkdir -p \"\$MOUNTPOINT\"
mount -t tmpfs -o \"mode=0755\" tmpfs \"\$MOUNTPOINT\" 2>/dev/null
) }



mnt_bind(){ (
# SHORTCUT BY BIND MOUNT
FROM=\"\$1\"; TO=\"\$2\"
if [ -L \"\$FROM\" ]; then
SOFTLN=\"\$(readlink \"\$FROM\")\"
ln -s \"\$SOFTLN\" \"\$TO\"
elif [ -d \"\$FROM\" ]; then
mkdir -p \"\$TO\" 2>/dev/null
mount --bind \"\$FROM\" \"\$TO\"
else
echo -n 2>/dev/null >\"\$TO\"
mount --bind \"\$FROM\" \"\$TO\"
fi
) }

clone(){ (
FROM=\"\$1\"; TO=\"\$2\"; IFS=\$\"
\"
[ -d \"\$TO\" ] || exit 1;
( cd \"\$FROM\" && find * -prune ) | while read obj; do
( if [ -d \"\$FROM/\$obj\" ]; then
mnt_tmpfs \"\$TO/\$obj\"
else
mnt_bind \"\$FROM/\$obj\" \"\$TO/\$obj\" 2>/dev/null
fi ) &
sleep 0.05
done
) }

overlay(){ (
# RE-OVERLAY A DIRECTORY
FOLDER=\"\$1\";
TMPFOLDER=\"/dev/vm-overlay\"
#_____
PAYDIR=\"\${TMPFOLDER}_\${RANDOM}_\$(date | base64)\"
mkdir -p \"\$PAYDIR\"
mnt_tmpfs \"\$PAYDIR\"
#_________
clone \"\$FOLDER\" \"\$PAYDIR\"
mount --move \"\$PAYDIR\" \"\$FOLDER\"
rm -rf \"\$PAYDIR\"
#______________
) }

exit_magisk(){
umount -l $MAGISKTMP
echo -n >/dev/.magisk_unblock
}


API=\$(getprop ro.build.version.sdk)
  ABI=\$(getprop ro.product.cpu.abi)
  if [ \"\$ABI\" = \"x86\" ]; then
    ARCH=x86
    ABI32=x86
    IS64BIT=false
  elif [ \"\$ABI\" = \"arm64-v8a\" ]; then
    ARCH=arm64
    ABI32=armeabi-v7a
    IS64BIT=true
  elif [ \"\$ABI\" = \"x86_64\" ]; then
    ARCH=x64
    ABI32=x86
    IS64BIT=true
  else
    ARCH=arm
    ABI=armeabi-v7a
    ABI32=armeabi-v7a
    IS64BIT=false
  fi

magisk_name=\"magisk32\"
[ \"\$IS64BIT\" == true ] && magisk_name=\"magisk64\"

# umount previous /sbin tmpfs overlay

count=0
( magisk --stop ) &

# force umount /sbin tmpfs

until ! mount | grep -q \" /sbin \"; do
[ "$count" -gt "10" ] && break
umount -l /sbin 2>/dev/null
sleep 0.1
count=$(($count+1))
test ! -d /sbin && break
done

# mount magisk tmpfs path

$mount_sbin

MAGISKTMP=$MAGISKTMP
chmod 755 \"\$MAGISKTMP\"
set -x
mkdir -p \$MAGISKTMP/.magisk
mkdir -p \$MAGISKTMP/emu
exec 2>>\$MAGISKTMP/emu/record_logs.txt
exec >>\$MAGISKTMP/emu/record_logs.txt

cd $MAGISKBASE 

test ! -f \"./\$magisk_name\" && { echo -n >/dev/.overlay_unblock; exit_magisk; exit 0; }


MAGISKBIN=/data/adb/magisk
mkdir /data/unencrypted
for mdir in modules post-fs-data.d service.d magisk; do
test ! -d /data/adb/\$mdir && rm -rf /data/adb/\$mdir
mkdir /data/adb/\$mdir 2>/dev/null
done
for file in magisk32 magisk64 magiskinit; do
  cp -af ./\$file \$MAGISKTMP/\$file 2>/dev/null
  chmod 755 \$MAGISKTMP/\$file
  cp -af ./\$file \$MAGISKBIN/\$file 2>/dev/null
  chmod 755 \$MAGISKBIN/\$file
done
cp -af ./magiskboot \$MAGISKBIN/magiskboot
cp -af ./busybox \$MAGISKBIN/busybox
cp -af ./busybox \$MAGISKTMP
chmod 755 \$MAGISKTMP/busybox
\$MAGISKTMP/busybox --install -s \$MAGISKTMP
cp -af ./assets/* \$MAGISKBIN

# create symlink / applet

ln -s ./\$magisk_name \$MAGISKTMP/magisk 2>/dev/null
ln -s ./magisk \$MAGISKTMP/su 2>/dev/null
ln -s ./magisk \$MAGISKTMP/resetprop 2>/dev/null
ln -s ./magisk \$MAGISKTMP/magiskhide 2>/dev/null
ln -s ./magiskinit \$MAGISKTMP/magiskpolicy 2>/dev/null

mkdir -p \$MAGISKTMP/.magisk/mirror
mkdir \$MAGISKTMP/.magisk/block

touch \$MAGISKTMP/.magisk/config

cd \$MAGISKTMP
# SELinux stuffs
ln -sf ./magiskinit magiskpolicy
if [ -f /vendor/etc/selinux/precompiled_sepolicy ]; then
  ./magiskpolicy --load /vendor/etc/selinux/precompiled_sepolicy --live --magisk 2>&1
elif [ -f /sepolicy ]; then
  ./magiskpolicy --load /sepolicy --live --magisk 2>&1
else
  ./magiskpolicy --live --magisk 2>&1
fi

#remount system read-only to fix Magisk fail to mount mirror

$remove_backup
mount -o ro,remount /
mount -o ro,remount /system
mount -o ro,remount /vendor
mount -o ro,remount /product
mount -o ro,remount /system_ext

restorecon -R /data/adb/magisk

$ADDITIONAL_SCRIPT
$LOAD_MODULES_POLICY

[ ! -f \"\$MAGISKTMP/magisk\" ] && exit_magisk
# test ! \"\$(pidof magiskd)\" && exit_magisk

[ -d "/oem/.overlay" ] && umount -l /oem
umount -l /system/etc/init
umount -l /init.rc
umount -l /system/etc/init/hw/init.rc
"
}
### <- taken from HuskyDG script MagiskOnEmu libbash.so

# This function checks for the existence of the su binary
CheckBlueStacksSUBinary(){
	SU="/system/xbin/bstk/su"
	echo "[-] Checking for build-in $SU binary"
	if [ ! -e $SU ]; then
		echo "[!] We need Root to get Root"
		echo "[!] No $SU could be found"
		abort_script
	fi
	echo "[*] $SU binary found"
	
	# Disable SELinux
	#$SU -c 'setenforce 0'	
} 

# This function is responsible for remounting a specific path as read-write and performing backup and copy operations related to the BlueStacks Ramdisk.
GetBlueStacksRamdisk() {
	echo "[*] Getting BlueStacks Ramdisk"

	BA="/boot/android"
	
	BSTKRDF="$BA/android/ramdisk.img"
	BSTKRDFBU="$BSTKRDF.backup"

	echo "[-] remounting $BA as RW"
	mount -o remount,rw $BA
	
	if [ ! -e $BSTKRDFBU ]; then
		echo "[*] Copy $BSTKRDF to $BSTKRDFBU"
		cp -fac $BSTKRDF $BSTKRDFBU
	fi
	
	echo "[*] Copy $BSTKRDF to $BASEDIR"
	cp -fac $BSTKRDF $BASEDIR/
}

# This function is responsible for performing various finalization tasks for BlueStacks, such as overwriting the ramdisk file, changing file permissions and ownership, cleaning folders, and remounting the specified path as read-only.
FinalizeBlueStacks() {
	if ! $DEBUG; then
		echo "[-] Overwriting $BSTKRDF with ramdiskpatched4AVD.img"
		cp -f ramdiskpatched4AVD.img $BSTKRDF
		echo "[-] Change ramdisk Mode to 644"
		chmod 644 $BSTKRDF
		echo "[-] Change ramdisk Owner to System"
		chown 1000:1000 $BSTKRDF
	fi
	
	echo "[*] Change $BASEDIR Owner back to Shell while root for deleting reasons"
	chown 2000:2000 $BASEDIR -R
	echo "[*] Cleaning /data/adb Folder"
	rm -rf /data/adb
	echo "[-] remounting $BA as RO"
	mount -o remount,ro $BA
}

# Taken from the Magisk Modules Template by topjohnwu
# set_perm <target> <owner> <group> <permission> [context]
#     if [context] is empty, it will default to "u:object_r:system_file:s0"
#     this function is a shorthand for the following commands
#       chown owner.group target
#       chmod permission target
#       chcon context target

# The purpose of this function is to provide a convenient way to set permissions, ownership, and SELinux context for a file within a shell script. It abstracts away the individual commands (chown, chmod, and chcon) and provides error handling by returning a non-zero value if any of the commands fail.
set_perm() {
	chown $2:$3 $1 || return 1
	chmod $4 $1 || return 1
	CON=$5
	[ -z $CON ] && CON=u:object_r:system_file:s0
	chcon $CON $1 || return 1
}

# set_perm_recursive <directory> <owner> <group> <dirpermission> <filepermission> [context]
#     if [context] is empty, it will default to "u:object_r:system_file:s0"
#     for all files in <directory>, it will call:
#       set_perm file owner group filepermission context
#     for all directories in <directory> (including itself), it will call:
#       set_perm dir owner group dirpermission context

# The purpose of this function is to apply the same set of permissions, ownership, and SELinux context recursively to all files and directories within a specified directory. It uses the find command to locate the files and directories and calls the set_perm function to set the permissions, ownership, and SELinux context for each file and directory individually.
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 -o -type l 2>/dev/null | while read file; do
	set_perm $file $2 $3 $5 $6
	done
}

# This function is responsible for setting permissions and SELinux contexts for various files and directories related to BlueStacks Magisk integration.
SettingBlueStackMagiskPermissions() {
	echo "[*] Setting BlueStack Magisk Permissions"
	local ROOT=$(stat -c %u /dev)
	cd $BLSTKMAGISKDIR/ > /dev/null
		set_perm_recursive assets $ROOT $ROOT 0750 0777	
		set_perm ./busybox $ROOT $ROOT 0750 u:object_r:magisk_file:s0	
		
		if [ -e "magisk64" ]; then			
			set_perm ./magisk64 $ROOT $ROOT 0750 u:object_r:magisk_exec:s0
		elif [ -e "magisk32" ]; then			
			set_perm ./magisk32 $ROOT $ROOT 0750 u:object_r:magisk_exec:s0
		fi
				
		set_perm ./magiskboot $ROOT $ROOT 0750
		set_perm ./magiskinit $ROOT $ROOT 0750
		set_perm ./overlay.sh $ROOT $ROOT 0750
		set_perm ../init.rc $ROOT $ROOT 0750
	cd - > /dev/null
}

# The purpose of this function is to prepare the BlueStacks ramdisk for Magisk installation by copying the necessary Magisk files and directories, generating boot scripts, setting permissions, and repacking the ramdisk with the patched files. This enables Magisk functionality within BlueStacks.
InstallMagiskIntoBlueStacksRamdisk() {
	echo "[-] Patching BlueStacks ramdisk .."
	echo "[*] Taken from HuskyDG script MagiskOnEmu/libbash.so"
	
	MAGISKBASE="/magisk"
	BLSTKMAGISKDIR=$TMP/ramdisk$MAGISKBASE
	local INITRC=$TMP/ramdisk/init.rc
	rm -rf $BLSTKMAGISKDIR 2>/dev/null
	mkdir -p $BLSTKMAGISKDIR
	echo "[-] copying Magisk Assets and Files"
	cp -Rf $BASEDIR/assets $BLSTKMAGISKDIR/
	cp $BB $BLSTKMAGISKDIR/
	cp $BASEDIR/magisk32 $BLSTKMAGISKDIR/
	cp $BASEDIR/magisk64 $BLSTKMAGISKDIR/
	cp $BASEDIR/magiskboot $BLSTKMAGISKDIR/
	cp $BASEDIR/magiskinit $BLSTKMAGISKDIR/
	cp $INITRC $BLSTKMAGISKDIR/
	echo "[*] generating Magisk Boot Scripts"
	magisk_loader
	echo "[*] Magisk files will be mounted to $MAGISKTMP"	
	echo "[-] writing overlay.sh Script"
	echo "$overlay_loader" >"$BLSTKMAGISKDIR/overlay.sh"
	echo "[*] appending boot commands to init.rc"
	echo "$magiskloader" >> "$TMP/ramdisk/init.rc"
	
	# setting permissions
	SettingBlueStackMagiskPermissions
	
	echo "[-] Repacking BlueStacks ramdisk .."
	cd $TMP/ramdisk > /dev/null
		`find . | cpio -H newc -o > $CPIO`
	cd - > /dev/null
}

# This function appears to be a placeholder function for testing the "service" module.
service(){
	echo "[-] service Module testing"
	#exit
}

# This function is responsible for installing Magisk on the AVD (Android Virtual Device) or emulator.
InstallMagiskToAVD() {

	if [ -z $PREPBBMAGISK ]; then
		ProcessArguments $@		
		api_level_arch_detect
		PrepBusyBoxAndMagisk	
		ExecBusyBoxAsh $@
	fi
	
	echo "[*] rootAVD with Magisk $MAGISK_VER Installer"
	
	get_flags
	copyARCHfiles

	#$ENVFIXTASK && construct_environment
	
	if [ "$DERIVATE" == "BlueStacks" ]; then
		GetBlueStacksRamdisk		
	fi

	if $INEMULATOR; then
		detect_ramdisk_compression_method
		decompress_ramdisk
		if $FAKEBOOTIMG; then
			process_fake_boot_img
		fi
		
		test_ramdisk_patch_status
		verify_ramdisk_origin
		
		if [ "$DERIVATE" == "BlueStacks" ]; then
			InstallMagiskIntoBlueStacksRamdisk
		else
			if $PATCHEDBOOTIMAGE; then
				apply_ramdisk_hacks
			else
				patching_ramdisk
			fi		
		fi
		
		## Magisk Module testing		
		if $DEBUG; then
			service
		fi		
		
		repacking_ramdisk
		rename_copy_magisk
	fi
	
	if [ "$DERIVATE" == "BlueStacks" ]; then
		FinalizeBlueStacks		
	fi
}

# This function is used to locate system image files (ramdisk.img) on the local machine.
FindSystemImages() {
	local HOME=~/
	local SYSIM_DIR_M=Library/Android/sdk/system-images
	local SYSIM_DIR_L=Android/Sdk/system-images
	local SYSIM_DIR=""
	local SYSIM_EX=""

	if [ -d "$HOME$SYSIM_DIR_M" ]; then
		SYSIM_DIR=$SYSIM_DIR_M
	elif [ -d "$HOME$SYSIM_DIR_L" ]; then
		SYSIM_DIR=$SYSIM_DIR_L
	else
		return 1
	fi

	cd $HOME > /dev/null
			for SI in $(find $SYSIM_DIR -type f -iname ramdisk.img); do
				if ( "$ListAllAVDs" ); then
					SYSIM_EX+=" ~/$SI"
				else
					SYSIM_EX="~/$SI"
				fi
			done
	cd - > /dev/null

	echo "${bold}./rootAVD.sh${normal}"
	echo "${bold}./rootAVD.sh ListAllAVDs${normal}"
	echo "${bold}./rootAVD.sh EnvFixTask${normal}"
	echo "${bold}./rootAVD.sh InstallApps${normal}"
	echo ""

	for SYSIM in $SYSIM_EX;do
		if [[ ! $SYSIM == "" ]]; then
			echo "${bold}./rootAVD.sh $SYSIM${normal}"
			echo "${bold}./rootAVD.sh $SYSIM DEBUG PATCHFSTAB GetUSBHPmodZ${normal}"
			echo "${bold}./rootAVD.sh $SYSIM restore${normal}"
			echo "${bold}./rootAVD.sh $SYSIM InstallKernelModules${normal}"
			echo "${bold}./rootAVD.sh $SYSIM InstallPrebuiltKernelModules${normal}"
			echo "${bold}./rootAVD.sh $SYSIM InstallPrebuiltKernelModules GetUSBHPmodZ PATCHFSTAB DEBUG${normal}"
			echo "${bold}./rootAVD.sh $SYSIM AddRCscripts${normal}"			
			echo ""
		fi
	done
}

# This function is used to display the help text and usage information for the rootAVD script.
ShowHelpText() {
bold=$(tput bold)
normal=$(tput sgr0)
echo "${bold}rootAVD A Script to root AVD by NewBit XDA${normal}"
echo ""
echo "Usage:	${bold}rootAVD [DIR/ramdisk.img] [OPTIONS] | [EXTRA_CMDS]${normal}"
echo "or:	${bold}rootAVD [ARGUMENTS]${normal}"
echo ""
echo "Arguments:"
echo "	${bold}ListAllAVDs${normal}			Lists Command Examples for ALL installed AVDs"
echo ""
echo "	${bold}EnvFixTask${normal}			Requires Additional Setup fix"
echo "					- construct Magisk Environment manual"
echo "					- only works with an already Magisk patched ramdisk.img"
echo "					- without [DIR/ramdisk.img] [OPTIONS] [PATCHFSTAB]"
echo "					- needed since Android 12 (S) rev.1"
echo "					- not needed anymore since Android 12 (S) API 31 and Magisk Alpha"
echo "					- Grant Shell Su Permissions will pop up a few times"
echo "					- the AVD will reboot automatically"
echo ""
echo "	${bold}InstallApps${normal}			Just install all APKs placed in the Apps folder"
echo ""
echo "Main operation mode:"
echo "	${bold}DIR${normal}				a path to an AVD system-image"
echo "					- must always be the ${bold}1st${normal} Argument after rootAVD"
echo "	"
echo "ADB Path | Ramdisk DIR:"
echo "	${bold}[M]ac/Darwin:${normal}			export PATH=~/Library/Android/sdk/platform-tools:\$PATH"
echo "					~/Library/Android/sdk/system-images/android-\$API/google_apis_playstore/x86_64/"
echo "	"
echo "	${bold}[L]inux:${normal}			export PATH=~/Android/Sdk/platform-tools:\$PATH"
echo "					~/Android/Sdk/system-images/android-\$API/google_apis_playstore/x86_64/"
echo "	"
echo "	${bold}[W]indows:${normal}			set PATH=%LOCALAPPDATA%\Android\Sdk\platform-tools;%PATH%"
echo "					%LOCALAPPDATA%\Android\Sdk\system-images\android-\$API\google_apis_playstore\x86_64\\"
echo "	"
echo "	${bold}\$API:${normal}				25,29,30,S,etc."
echo "	"
echo "Except for ${bold}EnvFixTask${normal}, ramdisk.img must be ${bold}untouched (stock).${normal}"
echo "	"
echo "Options:"
echo "	${bold}restore${normal}				restore all existing ${bold}.backup${normal} files, but doesn't delete them"
echo "					- the AVD doesn't need to be running"
echo "					- no other Argument after will be processed"
echo "	"
echo "	${bold}InstallKernelModules${normal}		install ${bold}custom build kernel and its modules${normal} into ramdisk.img"
echo "					- kernel (bzImage) and its modules (initramfs.img) are inside rootAVD"
echo "					- both files will be deleted after installation"
echo "	"
echo "	${bold}InstallPrebuiltKernelModules${normal}	download and install an ${bold}AOSP prebuilt kernel and its modules${normal} into ramdisk.img"
echo "					- similar to ${bold}InstallKernelModules${normal}, but the AVD needs to be online"
echo "	"
echo "	${bold}AddRCscripts${normal}			install all custom *.rc scripts, placed in the rootAVD folder, into ramdisk.img/overlay.d/sbin"
echo "	"
echo "Options are ${bold}exclusive${normal}, only one at the time will be processed."
echo "	"
echo "Extra Commands:"
echo "	${bold}DEBUG${normal}				${bold}Debugging Mode${normal}, prevents rootAVD to pull back any patched file"
echo "	"
echo "	${bold}PATCHFSTAB${normal}			${bold}fstab.ranchu${normal} will get patched to automount Block Devices like ${bold}/dev/block/sda1${normal}"
echo "					- other entries can be added in the script as well"
echo "					- a custom build Kernel might be necessary"
echo "	"
echo "	${bold}GetUSBHPmodZ${normal}			The ${bold}USB HOST Permissions Module Zip${normal} will be downloaded into ${bold}/sdcard/Download${normal}"
echo "	"
echo "Extra Commands can be ${bold}combined${normal}, there is no particular order."
echo "	"
echo "${bold}Notes: rootAVD will${normal}"
echo "- always create ${bold}.backup${normal} files of ${bold}ramdisk.img${normal} and ${bold}kernel-ranchu${normal}"
echo "- ${bold}replace${normal} both when done patching"
echo "- show a ${bold}Menu${normal}, to choose the Magisk Version ${bold}(Stable || Canary || Alpha)${normal}, if the AVD is ${bold}online${normal}"
echo "- make the ${bold}choosen${normal} Magisk Version to its ${bold}local${normal}"
echo "- install all APKs placed in the Apps folder"
echo "	"
echo "${bold}Command Examples:${normal}"
FindSystemImages
exit
}

# This function is used to process the command line arguments passed to the rootAVD script.
ProcessArguments() {
	DEBUG=false
	PATCHFSTAB=false
	GetUSBHPmodZ=false
	ENVFIXTASK=false
	RAMDISKIMG=false
	restore=false
	InstallKernelModules=false
	InstallPrebuiltKernelModules=false
	ListAllAVDs=false
	InstallApps=false
	UpdateBusyBoxScript=false
	AddRCscripts=false
	BLUESTACKS=false
	toggleRamdisk=false
	FAKEBOOTIMG=false

	# Call rootAVD with SOURCING if you just want to source it
	# or export SOURCING=true if you are in crosh
	if [ -z "$SOURCING" ]; then
		SOURCING=false
	fi
	if [[ "$@" == *"SOURCING"* ]]; then
		SOURCING=true
	fi

	# While debugging and developing you can turn this flag on
	if [[ "$@" == *"DEBUG"* ]]; then
		DEBUG=true
		# Shows whatever line get executed...
		#set -x
	fi

	# Call rootAVD with PATCHFSTAB if you want the RAMDISK merge your modded fstab.ranchu before Magisk Mirror gets mounted
	if [[ "$@" == *"PATCHFSTAB"* ]]; then
		PATCHFSTAB=true
	fi

	# Call rootAVD with GetUSBHPmodZ to download the usbhostpermissons module
	if [[ "$@" == *"GetUSBHPmodZ"* ]]; then
		GetUSBHPmodZ=true
	fi

	# Call rootAVD with ListAllAVDs to show all AVDs with command examples
	if [[ "$@" == *"ListAllAVDs"* ]]; then
		ListAllAVDs=true
	fi

	# Call rootAVD with InstallApps to just install all APKs placed in the Apps folder
	if [[ "$@" == *"InstallApps"* ]]; then
		InstallApps=true
	fi

	# Call rootAVD with UpdateBusyBoxScript to update the Busybox Version within the rootAVD.sh
	if [[ "$@" == *"UpdateBusyBoxScript"* ]]; then
		UpdateBusyBoxScript=true
	fi

	# Call rootAVD with AddRCscripts to add custom *.rc scripts into ramdisk.img/sbin/*.rc
	if [[ "$@" == *"AddRCscripts"* ]]; then
		AddRCscripts=true
	fi

	case $1 in
	  "EnvFixTask" )  # AVD requires additional setup
			ENVFIXTASK=true
		;;

	  * )
	  		RAMDISKIMG=true
		;;
	esac
	
	case $2 in
	  "restore" )
			restore=true
		;;

	  "InstallKernelModules" )
			InstallKernelModules=true
		;;

	  "InstallPrebuiltKernelModules" )
			InstallPrebuiltKernelModules=true
		;;
	esac

	# Call rootAVD with BLUESTACKS if you want to patch the ramdisk.img of a BlueStacks System
	if [[ "$@" == *"BLUESTACKS"* ]]; then
		BLUESTACKS=true
		RAMDISKIMG=false
	fi

	# Call rootAVD with toggleRamdisk if you want to toggle between patched and original ramdisk.img
	if [[ "$@" == *"toggleRamdisk"* ]]; then
		toggleRamdisk=true
	fi

	# Call rootAVD with FAKEBOOTIMG if you want to create a fake boot.img to patch the ramdisk.img via direct install
	if [[ "$@" == *"FAKEBOOTIMG"* ]]; then
		FAKEBOOTIMG=true
	fi

	export DEBUG
	export PATCHFSTAB
	export GetUSBHPmodZ
	export ENVFIXTASK
	export RAMDISKIMG
	export restore
	export InstallKernelModules
	export InstallPrebuiltKernelModules
	export ListAllAVDs
	export InstallApps
	export UpdateBusyBoxScript
	export AddRCscripts
	export BLUESTACKS
	export toggleRamdisk
	export SOURCING
	export FAKEBOOTIMG
}

# The script entry point begins by checking the environment in which the script is running. It determines whether it is running in an emulator shell or not.
# Script Entry Point
# Checking in which shell we are

INEMULATOR=false
SHELLRESULT=$(getprop 2>/dev/null)
SHELLRESULT="$?"
if [[ "$SHELLRESULT" == "0" ]]; then
	INEMULATOR=true
	DERIVATE=$(getprop ro.boot.hardware 2>/dev/null)
	if [[ "$DERIVATE" == "" ]]; then
		$(which /system/xbin/bstk/su > /dev/null 2>&1)
		DERIVATE="$?"
		if [[ "$DERIVATE" == "0" ]]; then
			DERIVATE="BlueStacks"			
		fi
	fi
	if [ ! -z $PREPBBMAGISK ]; then
		echo "[-] We are now in Magisk Busybox STANDALONE (D)ASH"
		# Don't use $BB from now on
	else
		echo "[!] We are in a $DERIVATE emulator shell"
	fi	
fi

#if [[ $SHELL == "ranchu" ]]; then
#	echo "[!] We are in an emulator shell"
#	RANCHU=true
#fi
#if [[ $SHELL == "cheets" ]]; then
#	echo "[!] We are in a ChromeOS shell"
#	RANCHU=true
#fi

export DERIVATE
export INEMULATOR

if $INEMULATOR; then
	InstallMagiskToAVD $@
	return 0
fi

ProcessArguments $@

if ( "$SOURCING" ); then
	return
fi

if ( "$DEBUG" ); then
	echo "[!] We are in Debug Mode"
fi

if ( ! "$ENVFIXTASK" && ! "$InstallApps" && ! "$BLUESTACKS"); then
	# If there is no file to work with, abort the script, except if it is a BlueStacks System
	if (checkfile "$1" -eq 0); then
		ShowHelpText
	fi
fi

echo "[!] and we are NOT in an emulator shell"

CopyMagiskToAVD $@

exit