How to Make/Build Android .apk in Termux

[RandomPersonLikesCode]

I'm really curious if i could Make/Build Android .apk in Android Itself (with Termux) with the SDK/NDK and Programming Language such as Java/Kotlin and C++?

[robertkirkman]

Yes it is possible but unfortunately, the exact steps depend very specifically on what exact Android APK you want to build.

For some kinds of APKs, the steps can be extremely convoluted to the point that it is basically easier to learn how to build the APK inside GitHub Actions and get builds that way, but if you show me the source code of the exact APK that you want to compile, then it is possible I might be able to write a script that can build it in Termux and show that to you.

[robertkirkman]

@RandomPersonLikesCode There is another thread where someone has an example of how to do it in Rust, not Java, Kotlin or C++

• Buildling Android apps from Android itself, using Termux: a howto guide #25272

On my github account, there is an example of such an app written in Java, C++ and C

however, there is a very important detail in both cases - both of us wrote our apps partly from scratch, or at least the boilerplate and build system code that connects our apps to Android's default GUI and default runtime environment, and this gave us very tight control over the design of the Android support code of our apps so that they were designed from the beginning to support the option of building inside of Termux.

If you want to build an app that is already completed and which someone else already made, but that other app was not designed to be built in Termux, but was rather designed to be built in GitHub Actions or Docker or another system like that, then the amount of additional code you will need to write or set up might be large.

[RandomPersonLikesCode]

Yes i mean like, Setup Project → Write Java/Kt/Cpp Code → Build the .apk from scratch with Gradle

[robertkirkman]

@RandomPersonLikesCode

yes for basic Java projects it's somewhat simple - the really difficult part does tend to begin when C++ is used, I guess, since for basic, simple APK projects, it is somewhat easy (you mentioned C++ so I still don't know exactly what kind of app you want to make - there are a lot of ways to do that part and what steps are required are completely different for every different way).

Here are the commands for building Appliberated/HelloWorldSelfAware, which is an arbitrary, recently-maintained Android APK hello world project written in Java, in Termux:

pkg upgrade
termux-setup-storage
pkg install git wget gradle aapt aapt2
git clone https://github.com/termux/termux-packages.git
cd termux-packages
export TERMUX_PKG_TMPDIR=$PREFIX/tmp TERMUX_JAVA_HOME=$PREFIX/lib/jvm/java-21-openjdk
scripts/setup-android-sdk.sh
cd ..
mkdir -p ~/.gradle
echo "android.aapt2FromMavenOverride=$PREFIX/bin/aapt2" > ~/.gradle/gradle.properties
git clone https://github.com/Appliberated/HelloWorldSelfAware.git
. termux-packages/scripts/properties.sh 
echo "sdk.dir=$ANDROID_HOME" > HelloWorldSelfAware/local.properties
sed -i \
    -e 's/targetSdk = 35/targetSdk = 34/g' \
    -e 's/compileSdk = 35/compileSdk = 34/g' \
    HelloWorldSelfAware/app/build.gradle.kts
cd HelloWorldSelfAware
gradle assembleDebug
cp app/build/outputs/apk/debug/app-debug.apk /storage/emulated/0/Download/

[robertkirkman]

@RandomPersonLikesCode

For now, if you want to build with targetSdk or compileSdk 35+, you need to either manually cross-compile and install this PR, or wait for it to be done:

• aapt: Bump to 15.0.0.23 #23671

In the mean time, to compile apps that have compileSdk 35, edit their code to use compileSdk 34 instead (like I have shown in the example above), which is compatible with the current Termux aapt and aapt2 from pkg install.

[RandomPersonLikesCode]

Thank you very much for the reply! By the mean of "With C++" is for Later, especially when my app tends big and needed C++ with NDK for the Heavy Part, or interacting with the Device Graphic API such as OpenGL ES and/or Vulkan, which i still don't know if it possible to make such APK directly in Termux.

[robertkirkman]

By the mean of "With C++" is for Later, especially when my app tends big and needed C++ with NDK for the Heavy Part, or interacting with the Device Graphic API such as OpenGL ES and/or Vulkan, which i still don't know if it possible to make such APK directly in Termux.

Sure, let me know when you get to that part and need to decide what to do!

It definitely is possible and I and others have done it. It's just harder and it can be a lot messier to set up and learn how to configure.

Consult the code I posted in these two locations for some examples:

• Optional non-cross-compilation support? lzhiyong/termux-ndk#165 (experimental, unfinished WIP project to compile arbitary C++-based APK apps in a theoretically open-ended way entirely inside Termux without using 3rd-party binaries)
• https://github.com/robertkirkman/sm64ex-coop The first open source online multiplayer 3D Mario app for Android, which I created in late 2022 by forking the first open source singleplayer 3D Mario app for Android and installing the multiplayer mod into it that was originally intended only for PC. Designed and tested from the ground up to build the C and C++ code of Mario 64 and its mods into an APK file entirely within Termux.

[Harshiv-Patel]

Using gradle daemon build may be too much for on-hardware builds as that can get pretty messy & mobile CPUs simply aren't equipped to handle that load and/or have enough RAM.

You can manually call all the build tools in a bash or cmake script or any language of your preference for bare bones quick & dirty app that doesn't span to hundreds of megabytes.

An example of what I use with bash :

#!/data/data/com.termux/files/usr/bin/bash
#===  primary directories & files ===
myDir="hrp"
workspace="/sdcard/$myDir/term/"
bDir="bin/"
classesDir=$bDir"classes/"
apkDir=$bDir"apk/"
sourceDir="src/"
assetsDir="assets/"
resDir="res/"

#Project Home Dir	#example "myprojectname/"
#homeDir="/data/data/com.termux/files/home/OpenGLES/Square1/"
homeDir="/mnt/sdcard/$myDir/term/projects/android/OpenGLES/Square1/"
#pkgDir 			#example "com/myapp/mypackage"
pkgDir="book/BouncySquare/"
#application name	#example "myapp"
apname="Square1"
logfile=$homeDir$bDir"log.txt"

# apk signing Variables
keyfile=$homeDir$apkDir"debug.keystore"
psswd="A clearly fake password"
alias_name="alias"

#===  build files  ===
manifest="AndroidManifest.xml"
compiledRes="temp.apk"
apkName=
#======	other Variables =======
compiler="ecj"
#compiler="javac2"

dexflag=
dx_nostrict=0
installflag=0
jarlibs=""
#arrays for program arguments and input files
aapt_args=( )
dxargs=( )
compilerargs=( )
sourcefiles=( )
classfiles=( )

#this forces the output to be suppressed
#do SILENT=[non-zero value] to disable redirection
redirect_cmd( ) {
     if [ -n "$SILENT" ]; then
        "$@" > /dev/null
    else
        "$@"
    fi
}

# generate a keystore
generate_keystore ( ) {
	if [[ -f "$keyfile" ]]; then
		echo "keystore file $keyfile already exists!"
	else
		keytool \
		-genkey \
		-v \
		-keystore "$keyfile" \
		-alias "$alias_name" \
		-storepass "$psswd" \
		-keypass "$psswd" \
		-keyalg RSA \
		-keysize 2048 \
		-validity 10000 \
		-dname "CN=Android Debug,O=Android,C=US"
	fi
}

sign_apk ( ) {
generate_keystore

echo "$psswd" | apksigner \
	sign \
	--ks "$keyfile" \
	"$compiledRes" 
}

# WARNING : do not change line numbers of above files, they're hard coded
# TODO : in v1.12 onwards, homeDir includes absolute path,
# so do not include $workspace Variable when referring to $homeDir
#function to Install the apk
install_apk ( ) {
#Only works if APK is on the sdcard
#	make sure that argument of '-d' option points to 
#	correct abstract path of apk, otherwise packageInstaller 
#	will give parsing errors
# 1.0 Old methid for android-5
#am start \
#  --user 0 \
#  -a android.intent.action.VIEW \
#  -t application/vnd.android.package-archive \
#  -d content://$homeDir$apkDir$apname"-signed.apk"

# new method for Android-11
	time am \
		broadcast \
		--user 0 \
		-a android.intent.action.VIEW \
		-d "$homeDir$apkDir$apname-signed.apk" \
		-n com.termux/com.termux.app.TermuxOpenReceiver

}

show_help ( ) {
yb="\033[37;44m" #colored title
nc="\033[0m"
echo -e "${yb} android application package builder                        ${nc}"
echo "Usage: maker_android.sh [Options]"
echo "Options:"
echo -e "\t -a \t enable Verbose output in aapt"
echo -e "\t -d \t enable Verbose output in dx"
echo -e "\t -j \t enable Verbose output in $compiler"
echo -e "\t -v \t enable Verbose output in all of above"
echo -e "\t -n \t enable '--no-strict' option in dx"
echo
echo -e "\t -i \t Install apk upon successfull build (via am)"
echo -e "\t -I \t install exiting apk from 'bin/apk' dir"
}

#process command line args if number of args is nonzero
if [ $# -ne 0 ]
then
	while getopts "adhiIjnrv" option
	do
		case $option in
			a) aapt_args+=( -v ) ;;
			d) dxargs+=( --verbose ) ;;
			i) installflag=1 ;;
			I) installflag=2 ;;
			j) compilerargs+=( -verbose ) ;;
			n) dx_nostrict=1 ;;
			v) 	aapt_args+=( -v )
				compilerargs+=( -verbose )
				dxargs+=( --verbose ) ;;
			*) show_help && exit ;;
		esac
	done
fi
#if Only Installation is required, install_apk and exit
(( $installflag == 2 )) && install_apk && exit 0
#build process starts here : get the R.java file path
Rfile=$sourceDir$pkgDir"R.java"
#cd into the home dir - this way it works when run from inside vim or any other folder
cd $homeDir
#	===== Clean up older build files=====
rm -rf $classesDir $apkDir/*.apk $apkDir/*.dex
#Rmove the R.java file as will be created by aapt
[[ -f $Rfile ]] && rm $Rfile
# Remove previous compiler log file
[[ -f $logfile ]] && rm $logfile

#create the needed directories
mkdir -p $classesDir
#setup aapt arguments
aapt_args+=( -f )
aapt_args+=( -u )
aapt_args+=( -A $assetsDir )
aapt_args+=( -M $manifest )
aapt_args+=( -F $apkDir$compiledRes )
aapt_args+=( -S $resDir )
aapt_args+=( -J $sourceDir$pkgDir )
#unused#-I $coreAndroidjar \
#Now use aapt p[ackage] command
aapt p "${aapt_args[@]}"
#go to src dir for compilation
cd $sourceDir
#setup compiler arguments
compilerargs+=( -d ../bin/classes/ )
#ecj will require location of android.jar per API lavel
#compilerargs+=( -bootclasspath /data/data/com.termux/files/usr/bin/android.jar )
compilerargs+=( -bootclasspath ~/storage/external-1/android_v2.3.3.jar )
#compilerargs+=( -warn:none )
#add any jarlib if exists
[[ ! -z $jarlibs ]] && \
compilerargs+=( -classpath "$jarlibs" )

sourcefiles+=( `find . -name '[A-Za-z0-9]*.java' -type f` )
#errstr=""
#a pattern to detect compiler errors
pattern='.java\:[0-9]*\: '
#call compiler compiler and redirect its output to a log file.
#display error info on screen
$compiler "${compilerargs[@]}" "${sourcefiles[@]}" \
	2>&1 | tee ../logs.jlog | \
	grep -e 'error' -e 'ERROR ' -e $pattern
#check for any compilation errors written in log file
errstr=$( cat ../logs.jlog | grep -e 'error' -e 'ERROR' -e $pattern )
#echo -e "erratr: "$errstr
#if there are any errors, stop building and exit
[[ ! -z "${errstr// }" ]] && echo "compilation errors" && exit 1

#on successfull compilation, go to compiled java classes
cd ../$classesDir
#setup dx arguments
#find any classfiles and dirs(expected to be java package stucture)
num_dirs=0
num_dirs=`ls -l|grep ^d|wc -l`	#matches number of dirs

(( $num_dirs > 0 )) && \
	classfiles+=( 
	`find . -maxdepth 1 -type d|cut -d$'\n' -f 2-` ) ||
	classfiles+=( `find . -type f -name '*.class'` )
#set up dx arguments
	dxargs+=( --dex )
	dxargs+=( --output=../apk/"classes.dex" )
	(( dx_nostrict == 0 )) && dxargs+=( --no-strict )
#in case of any external jar libs:
#dx requires space as delimeter, so replace ':' with ' '
	[[ ! -z $jarlibs ]] && classfiles+=( ${jarlibs//:/ } )
#call it with redirect_cmd to suppress usual 
# "processing xyz class" output
redirect_cmd dx "${dxargs[@]}" "${classfiles[@]}"
#Back out
cd $homeDir$apkDir
#we use aapt add option
aapt add \
		-f $compiledRes classes.dex
#And now sign it
apkName="$apname-signed.apk"
#for Android-5 this works, but not on Android-11
#apksigner \
#		-p "A clearly fake password" \
#		customAlias \
#		$compiledRes \
#		$apkName

#call signing function
sign_apk && cp "$compiledRes" "$apkName" || echo "signing failed, darn you signer!"
#Install app if asked or exit
(( $installflag == 1 )) && install_apk || exit 0

As you can see, I skip may tools like lint & proguard & what not, you can add usage of those in it & figure out how to use them correctly online fairly easily.

Providing correct arguments to each tool can take some trial & error & modern build tool chain would look rather different compared to what I have.

you have to 'borrow' atleast the android.jar file that android apps are built against from the android SDK, & any other libraries that you need are to be added to compiler's class path etc.

It takes some time to do what gradle would do for you with whole bunch of processing power. Depends on how badly you want to build on device, how much time can you invest etc. It's possible, but not as straight forward as on a PC