Remove support for android

2015-12-02 19:29:42 +01:00 · 2015-12-02 19:29:42 +01:00 · 33e3bb2e71
commit 33e3bb2e71
parent c96384b3db
57 changed files with 79 additions and 3866 deletions
--- a/.gitignore
+++ b/.gitignore
@ -55,13 +55,10 @@ doc/doxygen_*
 ## Build files
 CMakeFiles
 Makefile
-!build/android/Makefile
 cmake_install.cmake
 CMakeCache.txt
 CPackConfig.cmake
 CPackSourceConfig.cmake
-src/android_version.h
-src/android_version_githash.h
 src/cmake_config.h
 src/cmake_config_githash.h
 src/lua/build/
@ -71,17 +68,3 @@ locale/
 *.layout
 *.o
 *.a
-
-## Android build files
-build/android/assets
-build/android/bin
-build/android/Debug
-build/android/deps
-build/android/gen
-build/android/jni/src
-build/android/libs
-build/android/obj
-build/android/path.cfg
-build/android/and_env
-build/android/AndroidManifest.xml
-timestamp
--- a/build/android/AndroidManifest.xml.template
+++ b/build/android/AndroidManifest.xml.template
@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="net.minetest.minetest"
-	android:versionCode="###ANDROID_VERSION###"
-	android:versionName="###BASE_VERSION###.###ANDROID_VERSION###"
-	android:installLocation="auto">
-	<uses-sdk android:minSdkVersion="9"/>
-	<uses-feature android:glEsVersion="0x00010000" android:required="true"/>
-	<uses-permission android:name="android.permission.INTERNET" />
-	<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
-	###DEBUG_BUILD###
-	<application android:icon="@drawable/irr_icon" android:label="Minetest" android:theme="@android:style/Theme.NoTitleBar.Fullscreen" ###DEBUG_FLAG###>
-	<activity android:name=".MtNativeActivity"
-		android:label="Minetest"
-		android:launchMode="singleTask"
-		android:configChanges="orientation|keyboard|keyboardHidden|navigation"
-		android:screenOrientation="sensorLandscape"
-		android:clearTaskOnLaunch="true">
-		<intent-filter>
-			<action android:name="android.intent.action.MAIN" />
-			<category android:name="android.intent.category.LAUNCHER" />
-		</intent-filter>
-		<meta-data android:name="android.app.lib_name" android:value="minetest" />
-	</activity>
-	<activity android:name=".MinetestTextEntry"
-		android:theme="@style/Theme.Transparent"
-		android:excludeFromRecents="true">
-	</activity>
-	<activity android:name=".MinetestAssetCopy"
-		android:theme="@style/Theme.Transparent"
-		android:excludeFromRecents="true">
-	</activity>
-	</application>
-</manifest>
--- a/build/android/Makefile
+++ b/build/android/Makefile
@ -1,891 +0,0 @@
-# build options
-
-OS := $(shell uname)
-
-# compile with GPROF
-# GPROF = 1
-
-# build for build platform
-APP_PLATFORM = android-9
-
-# paths used for timestaps, dependencys, tree config and libs
-PATHCFGFILE = path.cfg
-
-ROOT = $(shell pwd)
-
-GAMES_TO_COPY = minetest_game
-MODS_TO_COPY =
-
-
-VERSION_MAJOR := $(shell cat $(ROOT)/../../CMakeLists.txt | \
-	grep ^set\(VERSION_MAJOR\ | sed 's/)/ /' | cut -f2 -d' ')
-VERSION_MINOR := $(shell cat $(ROOT)/../../CMakeLists.txt | \
-	grep ^set\(VERSION_MINOR\ | sed 's/)/ /' | cut -f2 -d' ')
-VERSION_PATCH := $(shell cat $(ROOT)/../../CMakeLists.txt | \
-	grep ^set\(VERSION_PATCH\ | sed 's/)/ /' | cut -f2 -d' ')
-
-################################################################################
-# Android Version code
-# Increase for each build!
-################################################################################
-# Play Store actual version (16/03/15): 11
-ANDROID_VERSION_CODE = 13
-
-################################################################################
-# toolchain config for arm old processors
-################################################################################
-#TARGET_HOST = arm-linux
-#TARGET_ABI = armeabi
-#TARGET_LIBDIR = armeabi
-#TARGET_TOOLCHAIN = arm-linux-androideabi-
-#TARGET_CFLAGS_ADDON = -mfloat-abi=softfp -mfpu=vfp
-#TARGET_ARCH = arm
-#CROSS_PREFIX = arm-linux-androideabi-
-#COMPILER_VERSION = 4.8
-#HAVE_LEVELDB = 1
-
-################################################################################
-# toolchain config for arm new processors
-################################################################################
-TARGET_HOST = arm-linux
-TARGET_ABI = armeabi-v7a
-TARGET_LIBDIR = armeabi-v7a
-TARGET_TOOLCHAIN = arm-linux-androideabi-
-TARGET_CFLAGS_ADDON = -mfloat-abi=softfp -mfpu=vfpv3
-TARGET_CXXFLAGS_ADDON = $(TARGET_CFLAGS_ADDON)
-TARGET_ARCH = armv7
-CROSS_PREFIX = arm-linux-androideabi-
-COMPILER_VERSION = 4.8
-HAVE_LEVELDB = 1
-
-################################################################################
-# toolchain config for little endian mips
-################################################################################
-#TARGET_HOST = mipsel-linux
-#TARGET_ABI = mips
-#TARGET_LIBDIR = mips
-#TARGET_TOOLCHAIN = mipsel-linux-android-
-#TARGET_ARCH = mips32
-#CROSS_PREFIX = mipsel-linux-android-
-#COMPILER_VERSION = 4.8
-#HAVE_LEVELDB = 0
-
-################################################################################
-# toolchain config for x86
-################################################################################
-#TARGET_HOST = x86-linux
-#TARGET_ABI = x86
-#TARGET_LIBDIR = x86
-#TARGET_TOOLCHAIN = x86-
-#CROSS_PREFIX = i686-linux-android-
-#TARGET_ARCH = x86
-#COMPILER_VERSION = 4.8
-#HAVE_LEVELDB = 1
-
-################################################################################
-ASSETS_TIMESTAMP = deps/assets_timestamp
-
-LEVELDB_DIR = $(ROOT)/deps/leveldb/
-LEVELDB_LIB = $(LEVELDB_DIR)libleveldb.a
-LEVELDB_TIMESTAMP = $(LEVELDB_DIR)/timestamp
-LEVELDB_TIMESTAMP_INT = $(ROOT)/deps/leveldb_timestamp
-LEVELDB_URL_GIT = https://github.com/google/leveldb
-
-OPENAL_DIR = $(ROOT)/deps/openal-soft/
-OPENAL_LIB = $(OPENAL_DIR)libs/$(TARGET_ABI)/libopenal.so
-OPENAL_TIMESTAMP = $(OPENAL_DIR)/timestamp
-OPENAL_TIMESTAMP_INT = $(ROOT)/deps/openal_timestamp
-OPENAL_URL_GIT = https://github.com/apportable/openal-soft
-
-OGG_DIR = $(ROOT)/deps/libvorbis-libogg-android/
-OGG_LIB = $(OGG_DIR)libs/$(TARGET_ABI)/libogg.so
-VORBIS_LIB = $(OGG_DIR)libs/$(TARGET_ABI)/libogg.so
-OGG_TIMESTAMP = $(OGG_DIR)timestamp
-OGG_TIMESTAMP_INT = $(ROOT)/deps/ogg_timestamp
-OGG_URL_GIT = https://github.com/vincentjames501/libvorbis-libogg-android
-
-IRRLICHT_REVISION = 5122
-IRRLICHT_DIR = $(ROOT)/deps/irrlicht/
-IRRLICHT_LIB = $(IRRLICHT_DIR)lib/Android/libIrrlicht.a
-IRRLICHT_TIMESTAMP = $(IRRLICHT_DIR)timestamp
-IRRLICHT_TIMESTAMP_INT = $(ROOT)/deps/irrlicht_timestamp
-IRRLICHT_URL_SVN = http://svn.code.sf.net/p/irrlicht/code/branches/ogl-es@$(IRRLICHT_REVISION)
-
-OPENSSL_VERSION = 1.0.1p
-OPENSSL_BASEDIR = openssl-$(OPENSSL_VERSION)
-OPENSSL_DIR = $(ROOT)/deps/$(OPENSSL_BASEDIR)/
-OPENSSL_LIB = $(OPENSSL_DIR)/libssl.so.1.0.0
-OPENSSL_TIMESTAMP = $(OPENSSL_DIR)timestamp
-OPENSSL_TIMESTAMP_INT = $(ROOT)/deps/openssl_timestamp
-OPENSSL_URL = http://www.openssl.org/source/openssl-$(OPENSSL_VERSION).tar.gz
-
-CURL_VERSION = 7.45.0
-CURL_DIR = $(ROOT)/deps/curl-$(CURL_VERSION)
-CURL_LIB = $(CURL_DIR)/lib/.libs/libcurl.a
-CURL_TIMESTAMP = $(CURL_DIR)/timestamp
-CURL_TIMESTAMP_INT = $(ROOT)/deps/curl_timestamp
-CURL_URL_HTTP = http://curl.haxx.se/download/curl-${CURL_VERSION}.tar.bz2
-
-GMP_VERSION = 6.1.0
-GMP_DIR = $(ROOT)/deps/gmp-$(GMP_VERSION)
-GMP_LIB = $(GMP_DIR)/usr/lib/libgmp.so
-GMP_TIMESTAMP = $(GMP_DIR)/timestamp
-GMP_TIMESTAMP_INT = $(ROOT)/deps/gmp_timestamp
-GMP_URL_HTTP = https://gmplib.org/download/gmp/gmp-$(GMP_VERSION).tar.bz2
-
-FREETYPE_DIR = $(ROOT)/deps/freetype2-android/
-FREETYPE_LIB = $(FREETYPE_DIR)/Android/obj/local/$(TARGET_ABI)/libfreetype2-static.a
-FREETYPE_TIMESTAMP = $(FREETYPE_DIR)timestamp
-FREETYPE_TIMESTAMP_INT = $(ROOT)/deps/freetype_timestamp
-FREETYPE_URL_GIT = https://github.com/cdave1/freetype2-android
-
-ICONV_VERSION = 1.14
-ICONV_DIR = $(ROOT)/deps/libiconv/
-ICONV_LIB = $(ICONV_DIR)/lib/.libs/libiconv.so
-ICONV_TIMESTAMP = $(ICONV_DIR)timestamp
-ICONV_TIMESTAMP_INT = $(ROOT)/deps/iconv_timestamp
-ICONV_URL_HTTP = http://ftp.gnu.org/pub/gnu/libiconv/libiconv-$(ICONV_VERSION).tar.gz
-
-SQLITE3_FOLDER = sqlite-amalgamation-3090200
-SQLITE3_URL = http://www.sqlite.org/2015/$(SQLITE3_FOLDER).zip
-
-include $(PATHCFGFILE)
-
-#use interim target variable to switch leveldb on or off
-ifeq ($(HAVE_LEVELDB),1)
-	LEVELDB_TARGET = $(LEVELDB_LIB)
-endif
-
-.PHONY : debug release reconfig delconfig \
-	leveldb_download clean_leveldb leveldb\
-	irrlicht_download clean_irrlicht irrlicht \
-	clean_assets assets sqlite3_download \
-	freetype_download clean_freetype freetype \
-	apk clean_apk \
-	clean_all clean prep_srcdir \
-	install_debug install envpaths all \
-	manifest clean_manifest\
-	$(ASSETS_TIMESTAMP) $(LEVELDB_TIMESTAMP) \
-	$(OPENAL_TIMESTAMP) $(OGG_TIMESTAMP) \
-	$(IRRLICHT_TIMESTAMP) $(CURL_TIMESTAMP) \
-	$(OPENSSL_TIMESTAMP) curl_binary \
-	$(ROOT)/jni/src/android_version.h \
-	$(ROOT)/jni/src/android_version_githash.h
-
-debug : $(PATHCFGFILE)
-	export NDEBUG=;                                                            \
-	export BUILD_TYPE=debug;                                                   \
-	$(MAKE) apk
-
-all : debug release
-
-release : $(PATHCFGFILE)
-	@export NDEBUG=1;                                                          \
-	export BUILD_TYPE=release;                                                 \
-	$(MAKE) apk
-
-reconfig: delconfig
-	@$(MAKE) $(PATHCFGFILE)
-
-delconfig :
-	$(RM) ${PATHCFGFILE}
-
-$(PATHCFGFILE) :
-	@echo "Please specify path of ANDROID NDK";                                \
-	echo "e.g. /home/user/android-ndk-r9c/";                                   \
-	read ANDROID_NDK ;                                                         \
-	if [ ! -d $$ANDROID_NDK ] ; then                                           \
-		echo "$$ANDROID_NDK is not a valid folder";                            \
-		exit 1;                                                                \
-	fi;                                                                        \
-	echo "ANDROID_NDK = $$ANDROID_NDK" > ${PATHCFGFILE};                       \
-	echo "NDK_MODULE_PATH = $$ANDROID_NDK/toolchains" >> ${PATHCFGFILE};            \
-	echo "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";\
-	echo "+ Note: NDK_MODULE_PATH is set to $$ANDROID_NDK/toolchains";              \
-	echo "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";\
-	echo "Please specify path of ANDROID SDK";                                 \
-	echo "e.g. /home/user/adt-bundle-linux-x86_64-20131030/sdk/";              \
-	read SDKFLDR ;                                                             \
-	if [ ! -d $$SDKFLDR ] ; then                                               \
-		echo "$$SDKFLDR is not a valid folder";                                \
-		exit 1;                                                                \
-	fi;                                                                        \
-	echo "SDKFOLDER = $$SDKFLDR" >> ${PATHCFGFILE};
-
-$(OPENAL_TIMESTAMP) : openal_download
-	@LAST_MODIF=$$(find ${OPENAL_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${OPENAL_TIMESTAMP};                                            \
-	fi
-
-openal_download :
-	@if [ ! -d ${OPENAL_DIR} ] ; then                                          \
-		echo "openal sources missing, downloading...";                         \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd ${ROOT}/deps ;                                                      \
-		git clone ${OPENAL_URL_GIT} || exit 1;                                 \
-	fi
-
-openal : $(OPENAL_LIB)
-
-$(OPENAL_LIB): $(OPENAL_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${OPENAL_TIMESTAMP_INT} ] ; then                                 \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${OPENAL_TIMESTAMP} -nt ${OPENAL_TIMESTAMP_INT} ] ; then              \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	echo "changed timestamp for openal detected building...";                  \
-	cd ${OPENAL_DIR};                                                          \
-	ndk-build NDEBUG=${NDEBUG} NDK_MODULE_PATH=${NDK_MODULE_PATH}              \
-	APP_ABI=${TARGET_ABI} TARGET_ARCH_ABI=${TARGET_ABI}                        \
-	APP_PLATFORM=${APP_PLATFORM} TARGET_CFLAGS+="${TARGET_CFLAGS_ADDON}"       \
-	TARGET_LDFLAGS+="${TARGET_LDFLAGS_ADDON}"                                  \
-	TARGET_CXXFLAGS+="${TARGET_CXXFLAGS_ADDON}" || exit 1;                     \
-	touch ${OPENAL_TIMESTAMP};                                                 \
-	touch ${OPENAL_TIMESTAMP_INT};                                             \
-	else                                                                       \
-		echo "nothing to be done for openal";                                  \
-	fi
-
-clean_openal :
-	$(RM) -rf ${OPENAL_DIR}
-
-$(OGG_TIMESTAMP) : ogg_download
-	@LAST_MODIF=$$(find ${OGG_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${OGG_TIMESTAMP};                                                \
-	fi
-
-ogg_download :
-	@if [ ! -d ${OGG_DIR} ] ; then                                             \
-		echo "ogg sources missing, downloading...";                            \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd ${ROOT}/deps ;                                                      \
-		git clone ${OGG_URL_GIT}|| exit 1;                                     \
-		cd libvorbis-libogg-android ;                                          \
-		patch -p1 < ../../libvorbis-libogg-fpu.patch || exit 1;                \
-		sed -i 's-:-?-' jni/Application.mk;                                    \
-	fi
-
-ogg : $(OGG_LIB)
-
-$(OGG_LIB): $(OGG_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${OGG_TIMESTAMP_INT} ] ; then                                    \
-		echo "${OGG_TIMESTAMP_INT} doesn't exist";                             \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${OGG_TIMESTAMP} -nt ${OGG_TIMESTAMP_INT} ] ; then                    \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	echo "changed timestamp for ogg detected building...";                     \
-	cd ${OGG_DIR};                                                             \
-	ndk-build NDEBUG=${NDEBUG} NDK_MODULE_PATH=${NDK_MODULE_PATH}              \
-	APP_ABI=${TARGET_ABI} APP_PLATFORM=${APP_PLATFORM}                         \
-	TARGET_CFLAGS+="${TARGET_CFLAGS_ADDON}"                                    \
-	TARGET_LDFLAGS+="${TARGET_LDFLAGS_ADDON}"                                  \
-	TARGET_CXXFLAGS+="${TARGET_CXXFLAGS_ADDON}" || exit 1;                     \
-	touch ${OGG_TIMESTAMP};                                                    \
-	touch ${OGG_TIMESTAMP_INT};                                                \
-	else                                                                       \
-		echo "nothing to be done for libogg/libvorbis";                        \
-	fi
-
-clean_ogg :
-	$(RM) -rf ${OGG_DIR}
-
-$(OPENSSL_TIMESTAMP) : openssl_download
-	@LAST_MODIF=$$(find ${OPENSSL_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${OPENSSL_TIMESTAMP};                                            \
-	fi
-
-openssl_download :
-	@if [ ! -d ${OPENSSL_DIR} ] ; then                                         \
-		echo "openssl sources missing, downloading...";                        \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd ${ROOT}/deps ;                                                      \
-		wget ${OPENSSL_URL} || exit 1;                                         \
-		tar -xzf ${OPENSSL_BASEDIR}.tar.gz;                                    \
-		cd ${OPENSSL_BASEDIR};                                                 \
-		patch -p1 < ../../openssl_arch.patch;                                  \
-	fi
-
-openssl : $(OPENSSL_LIB)
-
-$(OPENSSL_LIB): $(OPENSSL_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${OPENSSL_TIMESTAMP_INT} ] ; then                                \
-		echo "${OPENSSL_TIMESTAMP_INT} doesn't exist";                         \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${OPENSSL_TIMESTAMP} -nt ${OPENSSL_TIMESTAMP_INT} ] ; then            \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	echo "changed timestamp for openssl detected building...";                 \
-	cd ${OPENSSL_DIR};                                                         \
-	ln -s ${OPENSSL_DIR} ../openssl;                                           \
-	export TOOLCHAIN=/tmp/ndk-${TARGET_HOST}-openssl;                          \
-	${ANDROID_NDK}/build/tools/make-standalone-toolchain.sh                    \
-	--toolchain=${TARGET_TOOLCHAIN}${COMPILER_VERSION}                         \
-	--install-dir=$${TOOLCHAIN};                                               \
-	export PATH="$${TOOLCHAIN}/bin:$${PATH}";                                  \
-	CC=${CROSS_PREFIX}gcc ./Configure android-${TARGET_ARCH} no-idea no-seed -no-sha0 -DL_ENDIAN;\
-	CC=${CROSS_PREFIX}gcc ANDROID_DEV=/tmp/ndk-${TARGET_HOST} make build_libs; \
-	touch ${OPENSSL_TIMESTAMP};                                                \
-	touch ${OPENSSL_TIMESTAMP_INT};                                            \
-	$(RM) -rf $${TOOLCHAIN};                                                   \
-	else                                                                       \
-		echo "nothing to be done for openssl";                        \
-	fi
-
-clean_openssl :
-	$(RM) -rf ${OPENSSL_DIR};                                                  \
-	$(RM) -rf $(ROOT)/deps/${OPENSSL_BASEDIR}.tar.gz;                          \
-	$(RM) -rf $(ROOT)/deps/openssl
-
-$(LEVELDB_TIMESTAMP) : leveldb_download
-	@LAST_MODIF=$$(find ${LEVELDB_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${LEVELDB_TIMESTAMP};                                            \
-	fi
-
-leveldb_download :
-	@if [ ! -d ${LEVELDB_DIR} ] ; then                                         \
-		echo "leveldb sources missing, downloading...";                        \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd ${ROOT}/deps ;                                                      \
-		git clone ${LEVELDB_URL_GIT} || exit 1;                                \
-	fi
-
-leveldb : $(LEVELDB_LIB)
-
-$(LEVELDB_LIB): $(LEVELDB_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${LEVELDB_TIMESTAMP_INT} ] ; then                                \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${LEVELDB_TIMESTAMP} -nt ${LEVELDB_TIMESTAMP_INT} ] ; then            \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	export PATH=$${PATH}:${SDKFOLDER}/platform-tools:${ANDROID_NDK};           \
-	echo "changed timestamp for leveldb detected building...";                 \
-	cd deps/leveldb;                                                           \
-	export CROSS_PREFIX=${CROSS_PREFIX};                                       \
-	export TOOLCHAIN=/tmp/ndk-${TARGET_HOST}-leveldb;                          \
-	${ANDROID_NDK}/build/tools/make-standalone-toolchain.sh                    \
-	--toolchain=${TARGET_TOOLCHAIN}${COMPILER_VERSION}                         \
-	--install-dir=$${TOOLCHAIN};                                               \
-	export PATH="$${TOOLCHAIN}/bin:$${PATH}";                                  \
-	export CC=${CROSS_PREFIX}gcc;                                              \
-	export CXX=${CROSS_PREFIX}g++;                                             \
-	export CFLAGS="$${CFLAGS} ${TARGET_CFLAGS_ADDON}";                         \
-	export CPPFLAGS="$${CPPFLAGS} ${TARGET_CFLAGS_ADDON}";                     \
-	export LDFLAGS="$${LDFLAGS} ${TARGET_LDFLAGS_ADDON}";                      \
-	export TARGET_OS=OS_ANDROID_CROSSCOMPILE;                                  \
-	$(MAKE) -s || exit 1;                                                      \
-	touch ${LEVELDB_TIMESTAMP};                                                \
-	touch ${LEVELDB_TIMESTAMP_INT};                                            \
-	$(RM) -rf $${TOOLCHAIN};                                                   \
-	else                                                                       \
-		echo "nothing to be done for leveldb";                                 \
-	fi
-
-clean_leveldb :
-	$(RM) -rf deps/leveldb
-
-$(FREETYPE_TIMESTAMP) : freetype_download
-	@LAST_MODIF=$$(find ${FREETYPE_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${FREETYPE_TIMESTAMP};                                           \
-	fi
-
-freetype_download :
-	@if [ ! -d ${FREETYPE_DIR} ] ; then                                        \
-		echo "freetype sources missing, downloading...";                       \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd deps;                                                               \
-		git clone ${FREETYPE_URL_GIT} || exit 1;                               \
-	fi
-
-freetype : $(FREETYPE_LIB)
-
-$(FREETYPE_LIB) : $(FREETYPE_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${FREETYPE_TIMESTAMP_INT} ] ; then                               \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ! -e ${FREETYPE_LIB} ] ; then                                         \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${FREETYPE_TIMESTAMP} -nt ${FREETYPE_TIMESTAMP_INT} ] ; then          \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	mkdir -p ${FREETYPE_DIR};                                                  \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	echo "changed timestamp for freetype detected building...";                \
-	cd ${FREETYPE_DIR}/Android/jni;                                            \
-	ndk-build NDEBUG=${NDEBUG} NDK_MODULE_PATH=${NDK_MODULE_PATH}              \
-	APP_PLATFORM=${APP_PLATFORM} APP_ABI=${TARGET_ABI}                         \
-	TARGET_CFLAGS+="${TARGET_CFLAGS_ADDON}"                                    \
-	TARGET_LDFLAGS+="${TARGET_LDFLAGS_ADDON}"                                  \
-	TARGET_CXXFLAGS+="${TARGET_CXXFLAGS_ADDON}" || exit 1;                     \
-	touch ${FREETYPE_TIMESTAMP};                                               \
-	touch ${FREETYPE_TIMESTAMP_INT};                                           \
-	else                                                                       \
-		echo "nothing to be done for freetype";                                \
-	fi
-
-clean_freetype :
-	$(RM) -rf ${FREETYPE_DIR}
-
-$(ICONV_TIMESTAMP) : iconv_download
-	@LAST_MODIF=$$(find ${ICONV_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${ICONV_TIMESTAMP};                                           \
-	fi
-
-iconv_download :
-	@if [ ! -d ${ICONV_DIR} ] ; then                                           \
-		echo "iconv sources missing, downloading...";                      \
-		mkdir -p ${ROOT}/deps;                                             \
-		cd ${ROOT}/deps;                                                   \
-		wget ${ICONV_URL_HTTP} || exit 1;                                  \
-		tar -xzf libiconv-${ICONV_VERSION}.tar.gz || exit 1;               \
-		rm libiconv-${ICONV_VERSION}.tar.gz;                               \
-		ln -s libiconv-${ICONV_VERSION} libiconv;                          \
-		cd ${ICONV_DIR};                                                   \
-		patch -p1 < ${ROOT}/libiconv_android.patch;                        \
-		patch -p1 < ${ROOT}/libiconv_stdio.patch;                          \
-	fi
-
-iconv : $(ICONV_LIB)
-
-$(ICONV_LIB) : $(ICONV_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${ICONV_TIMESTAMP_INT} ] ; then                                  \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ ! -e ${ICONV_LIB} ] ; then                                            \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ ${ICONV_TIMESTAMP} -nt ${ICONV_TIMESTAMP_INT} ] ; then                \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	mkdir -p ${ICONV_DIR};                                                     \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	echo "changed timestamp for iconv detected building...";                   \
-	cd ${ICONV_DIR};                                                           \
-	\
-	export TOOLCHAIN=/tmp/ndk-${TARGET_HOST}-iconv;                            \
-	${ANDROID_NDK}/build/tools/make-standalone-toolchain.sh                    \
-	--toolchain=${TARGET_TOOLCHAIN}${COMPILER_VERSION}                         \
-	--install-dir=$${TOOLCHAIN};                                               \
-	export PATH="$${TOOLCHAIN}/bin:$${PATH}";                                  \
-	export CC=${CROSS_PREFIX}gcc;                                              \
-	export CXX=${CROSS_PREFIX}g++;                                             \
-	export TARGET_OS=OS_ANDROID_CROSSCOMPILE;                                  \
-	./configure --host=${TARGET_HOST} || exit 1;                               \
-	sed -i 's/LIBICONV_VERSION_INFO) /LIBICONV_VERSION_INFO) -avoid-version /g' lib/Makefile; \
-	grep "iconv_LDFLAGS" src/Makefile;                                         \
-	$(MAKE) -s || exit 1;                                                      \
-	touch ${ICONV_TIMESTAMP};                                                  \
-	touch ${ICONV_TIMESTAMP_INT};                                              \
-	rm -rf ${TOOLCHAIN};                                                       \
-	else                                                                       \
-		echo "nothing to be done for iconv";                               \
-	fi
-
-clean_iconv :
-	$(RM) -rf ${ICONV_DIR}
-
-#Note: Texturehack patch is required for gpu's not supporting color format
-#      correctly. Known bad GPU:
-#      -geforce on emulator
-#      -Vivante Corporation GC1000 core (e.g. Galaxy Tab 3)
-
-irrlicht_download :
-	@if [ ! -d "deps/irrlicht" ] ; then                                        \
-		echo "irrlicht sources missing, downloading...";                       \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd deps;                                                               \
-		svn co ${IRRLICHT_URL_SVN} irrlicht || exit 1;                         \
-		cd irrlicht;                                                           \
-		patch -p1 < ../../irrlicht-touchcount.patch || exit 1;                 \
-		patch -p1 < ../../irrlicht-back_button.patch || exit 1;                \
-		patch -p1 < ../../irrlicht-texturehack.patch || exit 1;                \
-	fi
-
-$(IRRLICHT_TIMESTAMP) : irrlicht_download
-	@LAST_MODIF=$$(find ${IRRLICHT_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${IRRLICHT_TIMESTAMP};                                           \
-	fi
-
-irrlicht : $(IRRLICHT_LIB)
-
-$(IRRLICHT_LIB): $(IRRLICHT_TIMESTAMP) $(FREETYPE_LIB)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${IRRLICHT_TIMESTAMP_INT} ] ; then                               \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ! -e ${IRRLICHT_LIB} ] ; then                                         \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${IRRLICHT_TIMESTAMP} -nt ${IRRLICHT_TIMESTAMP_INT} ] ; then          \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	mkdir -p ${IRRLICHT_DIR};                                                  \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	echo "changed timestamp for irrlicht detected building...";                \
-	cd deps/irrlicht/source/Irrlicht/Android;                                  \
-	ndk-build NDEBUG=${NDEBUG} NDK_MODULE_PATH=${NDK_MODULE_PATH}              \
-	APP_ABI=${TARGET_ABI} APP_PLATFORM=${APP_PLATFORM}                         \
-	TARGET_CFLAGS+="${TARGET_CFLAGS_ADDON}"                                    \
-	TARGET_LDFLAGS+="${TARGET_LDFLAGS_ADDON}"                                  \
-	TARGET_CXXFLAGS+="${TARGET_CXXFLAGS_ADDON}" || exit 1;                     \
-	touch ${IRRLICHT_TIMESTAMP};                                               \
-	touch ${IRRLICHT_TIMESTAMP_INT};                                           \
-	else                                                                       \
-		echo "nothing to be done for irrlicht";                                \
-	fi
-
-clean_irrlicht :
-	$(RM) -rf deps/irrlicht
-
-$(CURL_TIMESTAMP) : curl_download
-	@LAST_MODIF=$$(find ${CURL_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${CURL_TIMESTAMP};                                               \
-	fi
-
-curl_download :
-	@if [ ! -d "deps/curl-${CURL_VERSION}" ] ; then                            \
-		echo "curl sources missing, downloading...";                           \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd deps;                                                               \
-		wget ${CURL_URL_HTTP} || exit 1;                                       \
-		tar -xjf curl-${CURL_VERSION}.tar.bz2 || exit 1;                       \
-		rm curl-${CURL_VERSION}.tar.bz2;                                       \
-		ln -s curl-${CURL_VERSION} curl;                                       \
-	fi
-
-curl : $(CURL_LIB)
-
-$(CURL_LIB): $(CURL_TIMESTAMP) $(OPENSSL_LIB)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${CURL_TIMESTAMP_INT} ] ; then                                   \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ! -e ${CURL_LIB} ] ; then                                             \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${CURL_TIMESTAMP} -nt ${CURL_TIMESTAMP_INT} ] ; then                  \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	mkdir -p ${CURL_DIR};                                                      \
-	export PATH="$${PATH}:${SDKFOLDER}/platform-tools:${ANDROID_NDK}";         \
-	echo "changed timestamp for curl detected building...";                    \
-	cd deps/curl-${CURL_VERSION};                                              \
-	export CROSS_PREFIX=${CROSS_PREFIX};                                       \
-	export TOOLCHAIN=/tmp/ndk-${TARGET_HOST}-curl;                             \
-	${ANDROID_NDK}/build/tools/make-standalone-toolchain.sh                    \
-	--toolchain=${TARGET_TOOLCHAIN}${COMPILER_VERSION}                         \
-	--install-dir=$${TOOLCHAIN};                                               \
-	export PATH="$${TOOLCHAIN}/bin:$${PATH}";                                  \
-	export CC=${CROSS_PREFIX}gcc;                                              \
-	export CXX=${CROSS_PREFIX}g++;                                             \
-	export TARGET_OS=OS_ANDROID_CROSSCOMPILE;                                  \
-	export CPPFLAGS="$${CPPFLAGS} -I${OPENSSL_DIR}/include                     \
-	-L${OPENSSL_DIR} ${TARGET_CFLAGS_ADDON}";                                  \
-	export CFLAGS="$${CFLAGS} ${TARGET_CFLAGS_ADDON}";                         \
-	export LDFLAGS="$${LDFLAGS} -L${OPENSSL_DIR} ${TARGET_LDFLAGS_ADDON}";     \
-	./configure --host=${TARGET_HOST} --disable-shared --enable-static --with-ssl;  \
-	$(MAKE) -s || exit 1;                                                      \
-	touch ${CURL_TIMESTAMP};                                                   \
-	touch ${CURL_TIMESTAMP_INT};                                               \
-	$(RM) -rf $${TOOLCHAIN};                                                   \
-	else                                                                       \
-		echo "nothing to be done for curl";                                    \
-	fi
-
-clean_curl :
-	$(RM) -rf deps/curl-${CURL_VERSION}                                        \
-	$(RM) -f deps/curl
-
-
-curl_binary:
-	@if [ ! -d "deps/curl-${CURL_VERSION_BINARY}" ] ; then                     \
-		echo "curl binary missing, downloading...";                           \
-		mkdir -p ${ROOT}/deps;                                                 \
-		cd deps;                                                               \
-		wget http://curl.haxx.se/gknw.net/7.34.0/dist-android/curl-7.34.0-rtmp-ssh2-ssl-zlib-static-bin-android.tar.gz || exit 1;\
-		tar -xzf curl-7.34.0-rtmp-ssh2-ssl-zlib-static-bin-android.tar.gz || exit 1;\
-		mv curl-7.34.0-rtmp-ssh2-ssl-zlib-static-bin-android curl-${CURL_VERSION_BINARY};\
-		rm curl-7.34.0-rtmp-ssh2-ssl-zlib-static-bin-android.tar.gz;           \
-	fi
-
-$(GMP_TIMESTAMP) : gmp_download
-	@LAST_MODIF=$$(find ${GMP_DIR} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${GMP_TIMESTAMP};                                            \
-	fi
-
-gmp_download :
-	@if [ ! -d "${GMP_DIR}" ] ; then                                           \
-		echo "gmp sources missing, downloading...";                        \
-		mkdir -p ${ROOT}/deps;                                             \
-		cd deps;                                                           \
-		wget ${GMP_URL_HTTP} || exit 1;                                    \
-		tar -xjf gmp-${GMP_VERSION}.tar.bz2 || exit 1;                     \
-		rm gmp-${GMP_VERSION}.tar.bz2;                                     \
-		ln -s gmp-${GMP_VERSION} gmp;                                      \
-	fi
-
-gmp : $(GMP_LIB)
-
-$(GMP_LIB): $(GMP_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${GMP_TIMESTAMP_INT} ] ; then                                    \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ ! -e ${GMP_LIB} ] ; then                                              \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ ${GMP_TIMESTAMP} -nt ${GMP_TIMESTAMP_INT} ] ; then                    \
-		REFRESH=1;                                                         \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	mkdir -p ${GMP_DIR};                                                       \
-	export PATH="$${PATH}:${SDKFOLDER}/platform-tools:${ANDROID_NDK}";         \
-	echo "changed timestamp for gmp detected building...";                     \
-	cd deps/gmp-${GMP_VERSION};                                                \
-	export CROSS_PREFIX=${CROSS_PREFIX};                                       \
-	export TOOLCHAIN=/tmp/ndk-${TARGET_HOST}-gmp;                              \
-	${ANDROID_NDK}/build/tools/make-standalone-toolchain.sh                    \
-	--toolchain=${TARGET_TOOLCHAIN}${COMPILER_VERSION}                         \
-	--install-dir=$${TOOLCHAIN};                                               \
-	export PATH="$${TOOLCHAIN}/bin:$${PATH}";                                  \
-	export CC=${CROSS_PREFIX}gcc;                                              \
-	export CXX=${CROSS_PREFIX}g++;                                             \
-	export LIBGMP_LDFLAGS="-avoid-version";                                    \
-	export LIBGMPXX_LDFLAGS="-avoid-version";                                  \
-	./configure --disable-static --host=${TARGET_HOST} --prefix=/usr;          \
-	$(MAKE) install DESTDIR=/${GMP_DIR} || exit 1;                             \
-	touch ${GMP_TIMESTAMP};                                                    \
-	touch ${GMP_TIMESTAMP_INT};                                                \
-	$(RM) -rf $${TOOLCHAIN};                                                   \
-	else                                                                       \
-		echo "nothing to be done for gmp";                                 \
-	fi
-
-clean_gmp:
-	$(RM) -rf deps/gmp-${GMP_VERSION}                                          \
-	$(RM) -f deps/gmp
-
-sqlite3_download: deps/${SQLITE3_FOLDER}/sqlite3.c
-
-deps/${SQLITE3_FOLDER}/sqlite3.c :
-	cd deps;                                                                    \
-	wget ${SQLITE3_URL};                                                        \
-	unzip ${SQLITE3_FOLDER}.zip;                                                \
-	ln -s ${SQLITE3_FOLDER} sqlite
-
-clean_sqlite3:
-	cd deps && $(RM) -rf ${SQLITE3_FOLDER} && $(RM) -f ${SQLITE3_FOLDER}.zip && \
-	$(RM) -f sqlite
-
-$(ASSETS_TIMESTAMP) : $(IRRLICHT_LIB)
-	@mkdir -p ${ROOT}/deps;                                                     \
-	for DIRNAME in {builtin,client,doc,fonts,games,mods,po,textures}; do        \
-		LAST_MODIF=$$(find ${ROOT}/../../${DIRNAME} -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-		if [ $$(basename $$LAST_MODIF) != "timestamp" ]; then               \
-			touch ${ROOT}/../../${DIRNAME}/timestamp;                   \
-			touch ${ASSETS_TIMESTAMP};                                  \
-			echo ${DIRNAME} changed $$LAST_MODIF;                       \
-		fi;                                                                 \
-	done;                                                                       \
-	LAST_MODIF=$$(find ${IRRLICHT_DIR}/media -type f -printf '%T@ %p\n' | sort -n | tail -1 | cut -f2- -d" "); \
-	if [ $$(basename $$LAST_MODIF) != "timestamp" ] ; then                     \
-		touch ${IRRLICHT_DIR}/media/timestamp;                                 \
-		touch ${ASSETS_TIMESTAMP};                                             \
-	fi;                                                                        \
-	if [ ${ROOT}/../../minetest.conf.example -nt ${ASSETS_TIMESTAMP} ] ; then  \
-		echo "conf changed";                                                   \
-		touch ${ASSETS_TIMESTAMP};                                             \
-	fi;                                                                        \
-	if [ ${ROOT}/../../README.txt -nt ${ASSETS_TIMESTAMP} ] ; then             \
-		touch ${ASSETS_TIMESTAMP};                                             \
-	fi;                                                                        \
-	if [ ! -e $(ASSETS_TIMESTAMP) ] ; then                                     \
-		touch $(ASSETS_TIMESTAMP);                                             \
-	fi
-
-assets : $(ASSETS_TIMESTAMP)
-	@REFRESH=0;                                                                \
-	if [ ! -e ${ASSETS_TIMESTAMP}.old ] ; then                                 \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ${ASSETS_TIMESTAMP} -nt ${ASSETS_TIMESTAMP}.old ] ; then              \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ ! -d ${ROOT}/assets ] ; then                                          \
-		REFRESH=1;                                                             \
-	fi;                                                                        \
-	if [ $$REFRESH -ne 0 ] ; then                                              \
-	echo "assets changed, refreshing...";                                      \
-	$(MAKE) clean_assets;                                                      \
-	mkdir -p ${ROOT}/assets/Minetest;                                          \
-	cp ${ROOT}/../../minetest.conf.example ${ROOT}/assets/Minetest;            \
-	cp ${ROOT}/../../README.txt ${ROOT}/assets/Minetest;                       \
-	cp -r ${ROOT}/../../builtin ${ROOT}/assets/Minetest;                       \
-	cp -r ${ROOT}/../../client ${ROOT}/assets/Minetest;                        \
-	cp -r ${ROOT}/../../doc ${ROOT}/assets/Minetest;                           \
-	cp -r ${ROOT}/../../fonts ${ROOT}/assets/Minetest;                         \
-	mkdir ${ROOT}/assets/Minetest/games;                                       \
-	for game in ${GAMES_TO_COPY}; do                                           \
-	    cp -r ${ROOT}/../../games/$$game ${ROOT}/assets/Minetest/games/;       \
-	done;                                                                      \
-	mkdir ${ROOT}/assets/Minetest/mods;                                        \
-	for mod in ${MODS_TO_COPY}; do                                             \
-	    cp -r ${ROOT}/../../mods/$$mod ${ROOT}/assets/Minetest/mods/;          \
-	done;                                                                      \
-	cp -r ${ROOT}/../../po ${ROOT}/assets/Minetest;                            \
-	cp -r ${ROOT}/../../textures ${ROOT}/assets/Minetest;                      \
-	mkdir -p ${ROOT}/assets/Minetest/media;                                    \
-	cp -r ${IRRLICHT_DIR}/media/Shaders ${ROOT}/assets/Minetest/media;         \
-	cd ${ROOT}/assets ||  exit 1;                                              \
-	find . -name "timestamp" -exec rm {} \; ;                                  \
-	find . -name "*.blend" -exec rm {} \; ;                                    \
-	find . -name "*~" -exec rm {} \; ;                                         \
-	find . -type d -path "*.git" -exec rm -rf {} \; ;                          \
-	find . -type d -path "*.svn" -exec rm -rf {} \; ;                          \
-	find . -type f -path "*.gitignore" -exec rm -rf {} \; ;                    \
-	ls -R | grep ":$$" | sed -e 's/:$$//' -e 's/\.//' -e 's/^\///' > "index.txt"; \
-	find Minetest >"filelist.txt";                                             \
-	cp ${ROOT}/${ASSETS_TIMESTAMP} ${ROOT}/${ASSETS_TIMESTAMP}.old;            \
-	else                                                                       \
-		echo "nothing to be done for assets";                                  \
-	fi
-
-clean_assets :
-	@$(RM) -r assets
-
-apk: $(PATHCFGFILE) assets $(ICONV_LIB) $(IRRLICHT_LIB) $(CURL_LIB) $(GMP_LIB) $(LEVELDB_TARGET)       \
-	$(OPENAL_LIB) $(OGG_LIB) prep_srcdir $(ROOT)/jni/src/android_version.h     \
-	$(ROOT)/jni/src/android_version_githash.h sqlite3_download
-	@export NDEBUG=$$NDEBUG; $(MAKE) manifest;                                 \
-	export PATH=$$PATH:${SDKFOLDER}/platform-tools:${ANDROID_NDK};             \
-	export ANDROID_HOME=${SDKFOLDER};                                          \
-	mkdir -p ${ROOT}/src;                                                      \
-	ndk-build NDK_MODULE_PATH=${NDK_MODULE_PATH}                               \
-	GPROF=${GPROF} APP_ABI=${TARGET_ABI} HAVE_LEVELDB=${HAVE_LEVELDB}          \
-	APP_PLATFORM=${APP_PLATFORM}                                               \
-	TARGET_LIBDIR=${TARGET_LIBDIR}                                             \
-	TARGET_CFLAGS+="${TARGET_CFLAGS_ADDON}"                                    \
-	TARGET_LDFLAGS+="${TARGET_LDFLAGS_ADDON}"                                  \
-	TARGET_CXXFLAGS+="${TARGET_CXXFLAGS_ADDON}" &&                             \
-	ant $$BUILD_TYPE &&                                                        \
-	echo "++ Success!" &&                                                      \
-	echo "APK: bin/Minetest-$$BUILD_TYPE.apk" &&                               \
-	echo "You can install it with \`adb install -r bin/Minetest-$$BUILD_TYPE.apk\`"
-
-prep_srcdir :
-	@if [ ! -e ${ROOT}/jni/src ]; then                                         \
-		ln -s ${ROOT}/../../src ${ROOT}/jni/src;                           \
-	fi
-
-clean_apk : manifest
-	@export PATH=$$PATH:${SDKFOLDER}platform-tools:${ANDROID_NDK};             \
-	export ANDROID_HOME=${SDKFOLDER};                                          \
-	ant clean
-
-install_debug :
-	@export PATH=$$PATH:${SDKFOLDER}platform-tools:${ANDROID_NDK};             \
-	adb install -r ${ROOT}/bin/Minetest-debug.apk
-
-install :
-	@export PATH=$$PATH:${SDKFOLDER}platform-tools:${ANDROID_NDK};             \
-	adb install -r ${ROOT}/bin/Minetest-release.apk
-
-envpaths :
-	@echo "export PATH=$$PATH:${SDKFOLDER}platform-tools:${ANDROID_NDK}" > and_env;\
-	echo "export ANDROID_HOME=${SDKFOLDER}" >> and_env;
-
-clean_all :
-	@$(MAKE) clean_apk;                                                        \
-	$(MAKE) clean_assets clean_iconv clean_irrlicht clean_leveldb clean_curl clean_openssl \
-	clean_openal clean_ogg clean_gmp clean_manifest;                           \
-	sleep 1;                                                                   \
-	$(RM) -r gen libs obj deps bin Debug and_env
-
-$(ROOT)/jni/src/android_version_githash.h : prep_srcdir
-	@export VERSION_FILE=${ROOT}/jni/src/android_version_githash.h;            \
-	export VERSION_FILE_NEW=$${VERSION_FILE}.new;                              \
-	{                                                                          \
-	echo "#ifndef ANDROID_MT_VERSION_GITHASH_H";                               \
-	echo "#define ANDROID_MT_VERSION_GITHASH_H";                               \
-	export GITHASH=$$(git rev-parse --short=8 HEAD);                           \
-	export VERSION_STR="${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}";   \
-	echo "#define VERSION_GITHASH \"$$VERSION_STR-$$GITHASH-Android\"";        \
-	echo "#endif";                                                             \
-	} > "$${VERSION_FILE_NEW}";                                                \
-	if ! cmp -s $${VERSION_FILE} $${VERSION_FILE_NEW}; then                    \
-		echo "android_version_githash.h changed, updating...";             \
-		mv "$${VERSION_FILE_NEW}" "$${VERSION_FILE}";                      \
-	else                                                                       \
-		rm "$${VERSION_FILE_NEW}";                                         \
-	fi
-
-
-$(ROOT)/jni/src/android_version.h : prep_srcdir
-	@export VERSION_FILE=${ROOT}/jni/src/android_version.h;                    \
-	export VERSION_FILE_NEW=$${VERSION_FILE}.new;                              \
-	{                                                                          \
-	echo "#ifndef ANDROID_MT_VERSION_H";                                       \
-	echo "#define ANDROID_MT_VERSION_H";                                       \
-	echo "#define VERSION_MAJOR ${VERSION_MAJOR}";                             \
-	echo "#define VERSION_MINOR ${VERSION_MINOR}";                             \
-	echo "#define VERSION_PATCH ${VERSION_PATCH}";                             \
-	echo "#define VERSION_STRING STR(VERSION_MAJOR)\".\"STR(VERSION_MINOR)\
-	\".\"STR(VERSION_PATCH)";                                                  \
-	echo "#endif";                                                             \
-	} > $${VERSION_FILE_NEW};                                                  \
-	if ! cmp -s $${VERSION_FILE} $${VERSION_FILE_NEW}; then                    \
-		echo "android_version.h changed, updating...";                     \
-		mv "$${VERSION_FILE_NEW}" "$${VERSION_FILE}";                      \
-	else                                                                       \
-		rm "$${VERSION_FILE_NEW}";                                         \
-	fi
-
-manifest :
-	@BASE_VERSION="${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}";        \
-	if [ "${NDEBUG}x" != "x" ] ; then                                          \
-		DBG='';                                                                \
-		DBG_FLAG="android:debuggable=\"false\"";                               \
-	else                                                                       \
-		DBG="<uses-permission android:name=\"android.permission.SET_DEBUG_APP\" />"; \
-		DBG_FLAG="android:debuggable=\"true\"";                                \
-	fi;                                                                        \
-	cat ${ROOT}/AndroidManifest.xml.template |                                 \
-	sed "s/###ANDROID_VERSION###/${ANDROID_VERSION_CODE}/g" |                  \
-	sed "s/###BASE_VERSION###/$$BASE_VERSION/g" |                              \
-	sed -e "s@###DEBUG_BUILD###@$$DBG@g" |                                     \
-	sed -e "s@###DEBUG_FLAG###@$$DBG_FLAG@g" >${ROOT}/AndroidManifest.xml
-
-clean_manifest :
-	rm -rf ${ROOT}/AndroidManifest.xml
-
-clean : clean_apk clean_assets
--- a/build/android/build.xml
+++ b/build/android/build.xml
@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="Minetest" default="help">
-	<property file="local.properties" />
-	<property file="ant.properties" />
-	<property environment="env" />
-	<condition property="sdk.dir" value="${env.ANDROID_HOME}">
-		<isset property="env.ANDROID_HOME" />
-	</condition>
-	<loadproperties srcFile="project.properties" />
-	<fail
-		message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable."
-		unless="sdk.dir"
-	/>
-	<import file="custom_rules.xml" optional="true" />
-	<import file="${sdk.dir}/tools/ant/build.xml" />
-</project>
--- a/build/android/irrlicht-back_button.patch
+++ b/build/android/irrlicht-back_button.patch
@ -1,19 +0,0 @@
--- irrlicht/source/Irrlicht/Android/CIrrDeviceAndroid.cpp	2014-06-03 20:56:21.289559503 +0200
-+++ irrlicht/source/Irrlicht/Android/CIrrDeviceAndroid.cpp.orig	2014-06-03 20:57:39.281556749 +0200
-@@ -423,6 +423,7 @@
- 			}
- 			
- 			device->postEventFromUser(event);
-+			status = 1;
- 		}
- 		break;
- 		default:
-@@ -479,7 +480,7 @@
-     KeyMap[1] = KEY_LBUTTON; // AKEYCODE_SOFT_LEFT
-     KeyMap[2] = KEY_RBUTTON; // AKEYCODE_SOFT_RIGHT
-     KeyMap[3] = KEY_HOME; // AKEYCODE_HOME
-    KeyMap[4] = KEY_BACK; // AKEYCODE_BACK
-+    KeyMap[4] = KEY_CANCEL; // AKEYCODE_BACK
-     KeyMap[5] = KEY_UNKNOWN; // AKEYCODE_CALL
-     KeyMap[6] = KEY_UNKNOWN; // AKEYCODE_ENDCALL
-     KeyMap[7] = KEY_KEY_0; // AKEYCODE_0
--- a/build/android/irrlicht-texturehack.patch
+++ b/build/android/irrlicht-texturehack.patch
@ -1,240 +0,0 @@
--- irrlicht/source/Irrlicht/COGLESTexture.cpp.orig	2014-06-22 17:01:13.266568869 +0200
-+++ irrlicht/source/Irrlicht/COGLESTexture.cpp	2014-06-22 17:03:59.298572810 +0200
-@@ -366,112 +366,140 @@
- 	void(*convert)(const void*, s32, void*) = 0;
- 	getFormatParameters(ColorFormat, InternalFormat, filtering, PixelFormat, PixelType, convert);
- 
-	// make sure we don't change the internal format of existing images
-	if (!newTexture)
-		InternalFormat = oldInternalFormat;
-
-    Driver->setActiveTexture(0, this);
-
-	if (Driver->testGLError())
-		os::Printer::log("Could not bind Texture", ELL_ERROR);
-
-	// mipmap handling for main texture
-	if (!level && newTexture)
-	{
-		// auto generate if possible and no mipmap data is given
-		if (!IsCompressed && HasMipMaps && !mipmapData && Driver->queryFeature(EVDF_MIP_MAP_AUTO_UPDATE))
-		{
-			if (Driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_SPEED))
-				glHint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
-			else if (Driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_QUALITY))
-				glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
-			else
-				glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);
-+	bool retry = false;
-+	
-+	do { 
-+		if (retry) {
-+			InternalFormat = GL_RGBA;
-+			PixelFormat = GL_RGBA;
-+			convert = CColorConverter::convert_A8R8G8B8toA8B8G8R8;
-+ 		}
-+		// make sure we don't change the internal format of existing images
-+		if (!newTexture)
-+			InternalFormat = oldInternalFormat;
- 
-            glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
-			AutomaticMipmapUpdate=true;
-		}
-+		Driver->setActiveTexture(0, this);
- 
-		// enable bilinear filter without mipmaps
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-	}
-+		if (Driver->testGLError())
-+			os::Printer::log("Could not bind Texture", ELL_ERROR);
- 
-	// now get image data and upload to GPU
-+		// mipmap handling for main texture
-+		if (!level && newTexture)
-+		{
-+			// auto generate if possible and no mipmap data is given
-+			if (!IsCompressed && HasMipMaps && !mipmapData && Driver->queryFeature(EVDF_MIP_MAP_AUTO_UPDATE))
-+			{
-+				if (Driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_SPEED))
-+					glHint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
-+				else if (Driver->getTextureCreationFlag(ETCF_OPTIMIZED_FOR_QUALITY))
-+					glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
-+				else
-+					glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);
-+
-+				glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
-+				AutomaticMipmapUpdate=true;
-+			}
-+
-+			// enable bilinear filter without mipmaps
-+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
-+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-+		}
- 
-	u32 compressedImageSize = IImage::getCompressedImageSize(ColorFormat, image->getDimension().Width, image->getDimension().Height);
-+		// now get image data and upload to GPU
- 
-	void* source = image->lock();
-+		u32 compressedImageSize = IImage::getCompressedImageSize(ColorFormat, image->getDimension().Width, image->getDimension().Height);
- 
-	IImage* tmpImage = 0;
-+		void* source = image->lock();
- 
-	if (convert)
-	{
-		tmpImage = new CImage(image->getColorFormat(), image->getDimension());
-		void* dest = tmpImage->lock();
-		convert(source, image->getDimension().getArea(), dest);
-		image->unlock();
-		source = dest;
-	}
-+		IImage* tmpImage = 0;
- 
-	if (newTexture)
-	{
-		if (IsCompressed)
-+		if (convert)
- 		{
-			glCompressedTexImage2D(GL_TEXTURE_2D, 0, InternalFormat, image->getDimension().Width,
-				image->getDimension().Height, 0, compressedImageSize, source);
-+			tmpImage = new CImage(image->getColorFormat(), image->getDimension());
-+			void* dest = tmpImage->lock();
-+			convert(source, image->getDimension().getArea(), dest);
-+			image->unlock();
-+			source = dest;
- 		}
-		else
-			glTexImage2D(GL_TEXTURE_2D, level, InternalFormat, image->getDimension().Width,
-				image->getDimension().Height, 0, PixelFormat, PixelType, source);
-	}
-	else
-	{
-		if (IsCompressed)
-+
-+		if (newTexture)
- 		{
-			glCompressedTexSubImage2D(GL_TEXTURE_2D, level, 0, 0, image->getDimension().Width,
-				image->getDimension().Height, PixelFormat, compressedImageSize, source);
-+			if (IsCompressed)
-+			{
-+				glCompressedTexImage2D(GL_TEXTURE_2D, 0, InternalFormat, image->getDimension().Width,
-+					image->getDimension().Height, 0, compressedImageSize, source);
-+			}
-+			else
-+				glTexImage2D(GL_TEXTURE_2D, level, InternalFormat, image->getDimension().Width,
-+					image->getDimension().Height, 0, PixelFormat, PixelType, source);
- 		}
- 		else
-			glTexSubImage2D(GL_TEXTURE_2D, level, 0, 0, image->getDimension().Width,
-				image->getDimension().Height, PixelFormat, PixelType, source);
-	}
-
-	if (convert)
-	{
-		tmpImage->unlock();
-		tmpImage->drop();
-	}
-	else
-		image->unlock();
-
-	if (!level && newTexture)
-	{
-		if (IsCompressed && !mipmapData)
- 		{
-			if (image->hasMipMaps())
-				mipmapData = static_cast<u8*>(image->lock())+compressedImageSize;
-+			if (IsCompressed)
-+			{
-+				glCompressedTexSubImage2D(GL_TEXTURE_2D, level, 0, 0, image->getDimension().Width,
-+					image->getDimension().Height, PixelFormat, compressedImageSize, source);
-+			}
- 			else
-				HasMipMaps = false;
-+				glTexSubImage2D(GL_TEXTURE_2D, level, 0, 0, image->getDimension().Width,
-+					image->getDimension().Height, PixelFormat, PixelType, source);
- 		}
- 
-		regenerateMipMapLevels(mipmapData);
-
-		if (HasMipMaps) // might have changed in regenerateMipMapLevels
-+		if (convert)
- 		{
-			// enable bilinear mipmap filter
-			GLint filteringMipMaps = GL_LINEAR_MIPMAP_NEAREST;
-
-			if (filtering != GL_LINEAR)
-				filteringMipMaps = GL_NEAREST_MIPMAP_NEAREST;
-+			tmpImage->unlock();
-+			tmpImage->drop();
-+		}
-+		else
-+			image->unlock();
-+		
-+		if (glGetError() != GL_NO_ERROR) {
-+			static bool warned = false;
-+			if ((!retry) && (ColorFormat == ECF_A8R8G8B8)) {
-+
-+				if (!warned) {
-+					os::Printer::log("Your driver claims to support GL_BGRA but fails on trying to upload a texture, converting to GL_RGBA and trying again", ELL_ERROR);
-+					warned = true;
-+				}
-+			}
-+			else if (retry) {
-+				os::Printer::log("Neither uploading texture as GL_BGRA nor, converted one using GL_RGBA succeeded", ELL_ERROR);
-+			}
-+			retry = !retry;
-+			continue;
-+		} else {
-+			retry = false;
-+		}
- 
-			glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filteringMipMaps);
-			glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-+		if (!level && newTexture)
-+		{
-+			if (IsCompressed && !mipmapData)
-+			{
-+				if (image->hasMipMaps())
-+					mipmapData = static_cast<u8*>(image->lock())+compressedImageSize;
-+				else
-+					HasMipMaps = false;
-+			}
-+
-+			regenerateMipMapLevels(mipmapData);
-+
-+			if (HasMipMaps) // might have changed in regenerateMipMapLevels
-+			{
-+				// enable bilinear mipmap filter
-+				GLint filteringMipMaps = GL_LINEAR_MIPMAP_NEAREST;
-+
-+				if (filtering != GL_LINEAR)
-+					filteringMipMaps = GL_NEAREST_MIPMAP_NEAREST;
-+
-+				glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filteringMipMaps);
-+				glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-+			}
- 		}
-	}
- 
-	if (Driver->testGLError())
-		os::Printer::log("Could not glTexImage2D", ELL_ERROR);
-+		if (Driver->testGLError())
-+			os::Printer::log("Could not glTexImage2D", ELL_ERROR);
-+	}
-+	while(retry);
- }
- 
- 
--- irrlicht/source/Irrlicht/COGLESTexture.cpp.orig	2014-06-25 00:28:50.820501856 +0200
-+++ irrlicht/source/Irrlicht/COGLESTexture.cpp	2014-06-25 00:08:37.712544692 +0200
-@@ -422,6 +422,9 @@
- 			source = dest;
- 		}
- 
-+		//clear old error
-+		glGetError();
-+
- 		if (newTexture)
- 		{
- 			if (IsCompressed)
--- a/build/android/irrlicht-touchcount.patch
+++ b/build/android/irrlicht-touchcount.patch
@ -1,30 +0,0 @@
--- irrlicht.orig/include/IEventReceiver.h	2014-06-03 19:43:50.433713133 +0200
-+++ irrlicht/include/IEventReceiver.h	2014-06-03 19:44:36.993711489 +0200
-@@ -375,6 +375,9 @@
-         // Y position of simple touch.
- 		s32 Y;
- 
-+		// number of current touches
-+		s32 touchedCount;
-+
- 		//! Type of touch event.
- 		ETOUCH_INPUT_EVENT Event;
- 	};
--- irrlicht.orig/source/Irrlicht/Android/CIrrDeviceAndroid.cpp	2014-06-03 19:43:50.505713130 +0200
-+++ irrlicht/source/Irrlicht/Android/CIrrDeviceAndroid.cpp	2014-06-03 19:45:37.265709359 +0200
-@@ -315,6 +315,7 @@
- 						event.TouchInput.ID = AMotionEvent_getPointerId(androidEvent, i);
- 						event.TouchInput.X = AMotionEvent_getX(androidEvent, i);
- 						event.TouchInput.Y = AMotionEvent_getY(androidEvent, i);
-+						event.TouchInput.touchedCount = AMotionEvent_getPointerCount(androidEvent);
- 
- 						device->postEventFromUser(event);
- 					}
-@@ -326,6 +327,7 @@
- 					event.TouchInput.ID = AMotionEvent_getPointerId(androidEvent, pointerIndex);
- 					event.TouchInput.X = AMotionEvent_getX(androidEvent, pointerIndex);
- 					event.TouchInput.Y = AMotionEvent_getY(androidEvent, pointerIndex);
-+					event.TouchInput.touchedCount = AMotionEvent_getPointerCount(androidEvent);
- 
- 					device->postEventFromUser(event);
- 				}
--- a/build/android/jni/Android.mk
+++ b/build/android/jni/Android.mk
@ -1,373 +0,0 @@
-LOCAL_PATH := $(call my-dir)/..
-
-#LOCAL_ADDRESS_SANITIZER:=true
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := Irrlicht
-LOCAL_SRC_FILES := deps/irrlicht/lib/Android/libIrrlicht.a
-include $(PREBUILT_STATIC_LIBRARY)
-
-ifeq ($(HAVE_LEVELDB), 1)
-	include $(CLEAR_VARS)
-	LOCAL_MODULE := LevelDB
-	LOCAL_SRC_FILES := deps/leveldb/libleveldb.a
-	include $(PREBUILT_STATIC_LIBRARY)
-endif
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := curl
-LOCAL_SRC_FILES := deps/curl/lib/.libs/libcurl.a
-include $(PREBUILT_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := freetype
-LOCAL_SRC_FILES := deps/freetype2-android/Android/obj/local/$(TARGET_ARCH_ABI)/libfreetype2-static.a
-include $(PREBUILT_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := iconv
-LOCAL_SRC_FILES := deps/libiconv/lib/.libs/libiconv.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := openal
-LOCAL_SRC_FILES := deps/openal-soft/libs/$(TARGET_LIBDIR)/libopenal.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := ogg
-LOCAL_SRC_FILES := deps/libvorbis-libogg-android/libs/$(TARGET_LIBDIR)/libogg.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := vorbis
-LOCAL_SRC_FILES := deps/libvorbis-libogg-android/libs/$(TARGET_LIBDIR)/libvorbis.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := gmp
-LOCAL_SRC_FILES := deps/gmp/usr/lib/libgmp.so
-include $(PREBUILT_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := ssl
-LOCAL_SRC_FILES := deps/openssl/libssl.a
-include $(PREBUILT_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := crypto
-LOCAL_SRC_FILES := deps/openssl/libcrypto.a
-include $(PREBUILT_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := minetest
-
-LOCAL_CPP_FEATURES += exceptions
-
-ifdef GPROF
-GPROF_DEF=-DGPROF
-endif
-
-LOCAL_CFLAGS := -D_IRR_ANDROID_PLATFORM_      \
-				-DHAVE_TOUCHSCREENGUI         \
-				-DUSE_CURL=1                  \
-				-DUSE_SOUND=1                 \
-				-DUSE_FREETYPE=1              \
-				-DUSE_LEVELDB=$(HAVE_LEVELDB) \
-				$(GPROF_DEF)                  \
-				-pipe -fstrict-aliasing
-
-ifndef NDEBUG
-LOCAL_CFLAGS += -g -D_DEBUG -O0 -fno-omit-frame-pointer
-else
-LOCAL_CFLAGS += -fexpensive-optimizations -O3
-endif
-
-ifdef GPROF
-PROFILER_LIBS := android-ndk-profiler
-LOCAL_CFLAGS += -pg
-endif
-
-# LOCAL_CFLAGS += -fsanitize=address
-# LOCAL_LDFLAGS += -fsanitize=address
-
-ifeq ($(TARGET_ARCH_ABI),x86)
-LOCAL_CFLAGS += -fno-stack-protector
-endif
-
-LOCAL_C_INCLUDES :=                               \
-		jni/src jni/src/sqlite                    \
-		jni/src/script                            \
-		jni/src/lua/src                           \
-		jni/src/json                              \
-		jni/src/cguittfont                        \
-		deps/irrlicht/include                     \
-		deps/libiconv/include                     \
-		deps/freetype2-android/include            \
-		deps/curl/include                         \
-		deps/openal-soft/jni/OpenAL/include       \
-		deps/libvorbis-libogg-android/jni/include \
-		deps/gmp/usr/include                      \
-		deps/leveldb/include                      \
-		deps/sqlite/
-
-LOCAL_SRC_FILES :=                                \
-		jni/src/areastore.cpp                     \
-		jni/src/ban.cpp                           \
-		jni/src/camera.cpp                        \
-		jni/src/cavegen.cpp                       \
-		jni/src/chat.cpp                          \
-		jni/src/client.cpp                        \
-		jni/src/clientiface.cpp                   \
-		jni/src/clientmap.cpp                     \
-		jni/src/clientmedia.cpp                   \
-		jni/src/clientobject.cpp                  \
-		jni/src/clouds.cpp                        \
-		jni/src/collision.cpp                     \
-		jni/src/content_abm.cpp                   \
-		jni/src/content_cao.cpp                   \
-		jni/src/content_cso.cpp                   \
-		jni/src/content_mapblock.cpp              \
-		jni/src/content_mapnode.cpp               \
-		jni/src/content_nodemeta.cpp              \
-		jni/src/content_sao.cpp                   \
-		jni/src/convert_json.cpp                  \
-		jni/src/craftdef.cpp                      \
-		jni/src/database-dummy.cpp                \
-		jni/src/database-sqlite3.cpp              \
-		jni/src/database.cpp                      \
-		jni/src/debug.cpp                         \
-		jni/src/defaultsettings.cpp               \
-		jni/src/drawscene.cpp                     \
-		jni/src/dungeongen.cpp                    \
-		jni/src/emerge.cpp                        \
-		jni/src/environment.cpp                   \
-		jni/src/filecache.cpp                     \
-		jni/src/filesys.cpp                       \
-		jni/src/fontengine.cpp                    \
-		jni/src/game.cpp                          \
-		jni/src/genericobject.cpp                 \
-		jni/src/gettext.cpp                       \
-		jni/src/guiChatConsole.cpp                \
-		jni/src/guiEngine.cpp                     \
-		jni/src/guiFileSelectMenu.cpp             \
-		jni/src/guiFormSpecMenu.cpp               \
-		jni/src/guiKeyChangeMenu.cpp              \
-		jni/src/guiPasswordChange.cpp             \
-		jni/src/guiTable.cpp                      \
-		jni/src/guiscalingfilter.cpp              \
-		jni/src/guiVolumeChange.cpp               \
-		jni/src/httpfetch.cpp                     \
-		jni/src/hud.cpp                           \
-		jni/src/imagefilters.cpp                  \
-		jni/src/intlGUIEditBox.cpp                \
-		jni/src/inventory.cpp                     \
-		jni/src/inventorymanager.cpp              \
-		jni/src/itemdef.cpp                       \
-		jni/src/keycode.cpp                       \
-		jni/src/light.cpp                         \
-		jni/src/localplayer.cpp                   \
-		jni/src/log.cpp                           \
-		jni/src/main.cpp                          \
-		jni/src/map.cpp                           \
-		jni/src/mapblock.cpp                      \
-		jni/src/mapblock_mesh.cpp                 \
-		jni/src/mapgen.cpp                        \
-		jni/src/mapgen_flat.cpp                   \
-		jni/src/mapgen_fractal.cpp                \
-		jni/src/mapgen_singlenode.cpp             \
-		jni/src/mapgen_v5.cpp                     \
-		jni/src/mapgen_v6.cpp                     \
-		jni/src/mapgen_v7.cpp                     \
-		jni/src/mapnode.cpp                       \
-		jni/src/mapsector.cpp                     \
-		jni/src/mesh.cpp                          \
-		jni/src/mg_biome.cpp                      \
-		jni/src/mg_decoration.cpp                 \
-		jni/src/mg_ore.cpp                        \
-		jni/src/mg_schematic.cpp                  \
-		jni/src/minimap.cpp                       \
-		jni/src/mods.cpp                          \
-		jni/src/nameidmapping.cpp                 \
-		jni/src/nodedef.cpp                       \
-		jni/src/nodemetadata.cpp                  \
-		jni/src/nodetimer.cpp                     \
-		jni/src/noise.cpp                         \
-		jni/src/objdef.cpp                        \
-		jni/src/object_properties.cpp             \
-		jni/src/particles.cpp                     \
-		jni/src/pathfinder.cpp                    \
-		jni/src/player.cpp                        \
-		jni/src/porting_android.cpp               \
-		jni/src/porting.cpp                       \
-		jni/src/profiler.cpp                      \
-		jni/src/quicktune.cpp                     \
-		jni/src/rollback.cpp                      \
-		jni/src/rollback_interface.cpp            \
-		jni/src/serialization.cpp                 \
-		jni/src/server.cpp                        \
-		jni/src/serverlist.cpp                    \
-		jni/src/serverobject.cpp                  \
-		jni/src/shader.cpp                        \
-		jni/src/sky.cpp                           \
-		jni/src/socket.cpp                        \
-		jni/src/sound.cpp                         \
-		jni/src/sound_openal.cpp                  \
-		jni/src/staticobject.cpp                  \
-		jni/src/subgame.cpp                       \
-		jni/src/tool.cpp                          \
-		jni/src/treegen.cpp                       \
-		jni/src/version.cpp                       \
-		jni/src/voxel.cpp                         \
-		jni/src/voxelalgorithms.cpp               \
-		jni/src/util/auth.cpp                     \
-		jni/src/util/base64.cpp                   \
-		jni/src/util/directiontables.cpp          \
-		jni/src/util/numeric.cpp                  \
-		jni/src/util/pointedthing.cpp             \
-		jni/src/util/serialize.cpp                \
-		jni/src/util/sha1.cpp                     \
-		jni/src/util/string.cpp                   \
-		jni/src/util/srp.cpp                      \
-		jni/src/util/timetaker.cpp                \
-		jni/src/unittest/test.cpp                 \
-		jni/src/unittest/test_collision.cpp       \
-		jni/src/unittest/test_compression.cpp     \
-		jni/src/unittest/test_connection.cpp      \
-		jni/src/unittest/test_filepath.cpp        \
-		jni/src/unittest/test_inventory.cpp       \
-		jni/src/unittest/test_mapnode.cpp         \
-		jni/src/unittest/test_nodedef.cpp         \
-		jni/src/unittest/test_noderesolver.cpp    \
-		jni/src/unittest/test_noise.cpp           \
-		jni/src/unittest/test_objdef.cpp          \
-		jni/src/unittest/test_profiler.cpp        \
-		jni/src/unittest/test_random.cpp          \
-		jni/src/unittest/test_schematic.cpp       \
-		jni/src/unittest/test_serialization.cpp   \
-		jni/src/unittest/test_settings.cpp        \
-		jni/src/unittest/test_socket.cpp          \
-		jni/src/unittest/test_utilities.cpp       \
-		jni/src/unittest/test_voxelalgorithms.cpp \
-		jni/src/unittest/test_voxelmanipulator.cpp \
-		jni/src/touchscreengui.cpp                \
-		jni/src/database-leveldb.cpp              \
-		jni/src/settings.cpp                      \
-		jni/src/wieldmesh.cpp                     \
-		jni/src/client/clientlauncher.cpp         \
-		jni/src/client/tile.cpp
-
-# intentionally kept out (we already build openssl itself): jni/src/util/sha256.c
-
-# Network
-LOCAL_SRC_FILES +=                                \
-		jni/src/network/connection.cpp            \
-		jni/src/network/networkpacket.cpp         \
-		jni/src/network/clientopcodes.cpp         \
-		jni/src/network/clientpackethandler.cpp   \
-		jni/src/network/serveropcodes.cpp         \
-		jni/src/network/serverpackethandler.cpp   \
-
-# lua api
-LOCAL_SRC_FILES +=                                \
-		jni/src/script/common/c_content.cpp       \
-		jni/src/script/common/c_converter.cpp     \
-		jni/src/script/common/c_internal.cpp      \
-		jni/src/script/common/c_types.cpp         \
-		jni/src/script/cpp_api/s_async.cpp        \
-		jni/src/script/cpp_api/s_base.cpp         \
-		jni/src/script/cpp_api/s_entity.cpp       \
-		jni/src/script/cpp_api/s_env.cpp          \
-		jni/src/script/cpp_api/s_inventory.cpp    \
-		jni/src/script/cpp_api/s_item.cpp         \
-		jni/src/script/cpp_api/s_mainmenu.cpp     \
-		jni/src/script/cpp_api/s_node.cpp         \
-		jni/src/script/cpp_api/s_nodemeta.cpp     \
-		jni/src/script/cpp_api/s_player.cpp       \
-		jni/src/script/cpp_api/s_security.cpp     \
-		jni/src/script/cpp_api/s_server.cpp       \
-		jni/src/script/lua_api/l_areastore.cpp    \
-		jni/src/script/lua_api/l_base.cpp         \
-		jni/src/script/lua_api/l_craft.cpp        \
-		jni/src/script/lua_api/l_env.cpp          \
-		jni/src/script/lua_api/l_inventory.cpp    \
-		jni/src/script/lua_api/l_item.cpp         \
-		jni/src/script/lua_api/l_mainmenu.cpp     \
-		jni/src/script/lua_api/l_mapgen.cpp       \
-		jni/src/script/lua_api/l_nodemeta.cpp     \
-		jni/src/script/lua_api/l_nodetimer.cpp    \
-		jni/src/script/lua_api/l_noise.cpp        \
-		jni/src/script/lua_api/l_object.cpp       \
-		jni/src/script/lua_api/l_particles.cpp    \
-		jni/src/script/lua_api/l_rollback.cpp     \
-		jni/src/script/lua_api/l_server.cpp       \
-		jni/src/script/lua_api/l_settings.cpp     \
-		jni/src/script/lua_api/l_util.cpp         \
-		jni/src/script/lua_api/l_vmanip.cpp       \
-		jni/src/script/scripting_game.cpp         \
-		jni/src/script/scripting_mainmenu.cpp
-
-#freetype2 support
-LOCAL_SRC_FILES +=                                \
-		jni/src/cguittfont/xCGUITTFont.cpp
-
-# lua
-LOCAL_SRC_FILES +=                                \
-		jni/src/lua/src/lapi.c                    \
-		jni/src/lua/src/lauxlib.c                 \
-		jni/src/lua/src/lbaselib.c                \
-		jni/src/lua/src/lcode.c                   \
-		jni/src/lua/src/ldblib.c                  \
-		jni/src/lua/src/ldebug.c                  \
-		jni/src/lua/src/ldo.c                     \
-		jni/src/lua/src/ldump.c                   \
-		jni/src/lua/src/lfunc.c                   \
-		jni/src/lua/src/lgc.c                     \
-		jni/src/lua/src/linit.c                   \
-		jni/src/lua/src/liolib.c                  \
-		jni/src/lua/src/llex.c                    \
-		jni/src/lua/src/lmathlib.c                \
-		jni/src/lua/src/lmem.c                    \
-		jni/src/lua/src/loadlib.c                 \
-		jni/src/lua/src/lobject.c                 \
-		jni/src/lua/src/lopcodes.c                \
-		jni/src/lua/src/loslib.c                  \
-		jni/src/lua/src/lparser.c                 \
-		jni/src/lua/src/lstate.c                  \
-		jni/src/lua/src/lstring.c                 \
-		jni/src/lua/src/lstrlib.c                 \
-		jni/src/lua/src/ltable.c                  \
-		jni/src/lua/src/ltablib.c                 \
-		jni/src/lua/src/ltm.c                     \
-		jni/src/lua/src/lundump.c                 \
-		jni/src/lua/src/lvm.c                     \
-		jni/src/lua/src/lzio.c                    \
-		jni/src/lua/src/print.c
-
-# SQLite3
-LOCAL_SRC_FILES += deps/sqlite/sqlite3.c
-
-# Threading
-LOCAL_SRC_FILES += \
-		jni/src/threading/mutex.cpp \
-		jni/src/threading/semaphore.cpp \
-		jni/src/threading/thread.cpp
-
-# JSONCPP
-LOCAL_SRC_FILES += jni/src/json/jsoncpp.cpp
-
-LOCAL_SHARED_LIBRARIES := iconv openal ogg vorbis gmp
-LOCAL_STATIC_LIBRARIES := Irrlicht freetype curl ssl crypto android_native_app_glue $(PROFILER_LIBS)
-
-ifeq ($(HAVE_LEVELDB), 1)
-	LOCAL_STATIC_LIBRARIES += LevelDB
-endif
-LOCAL_LDLIBS := -lEGL -llog -lGLESv1_CM -lGLESv2 -lz -landroid
-
-include $(BUILD_SHARED_LIBRARY)
-
-# at the end of Android.mk
-ifdef GPROF
-$(call import-module,android-ndk-profiler)
-endif
-$(call import-module,android/native_app_glue)
--- a/build/android/jni/Application.mk
+++ b/build/android/jni/Application.mk
@ -1,8 +0,0 @@
-# NDK_TOOLCHAIN_VERSION := clang3.3
-
-APP_PLATFORM := android-9
-APP_MODULES := minetest
-APP_STL := gnustl_static
-
-APP_CPPFLAGS += -fexceptions
-APP_GNUSTL_FORCE_CPP_FEATURES := rtti
--- a/build/android/libiconv_android.patch
+++ b/build/android/libiconv_android.patch
@ -1,39 +0,0 @@
--- a/libcharset/lib/localcharset.c	2015-06-10 11:55:25.933870724 +0200
-+++ b/libcharset/lib/localcharset.c	2015-06-10 11:55:39.578063493 +0200
-@@ -47,7 +47,7 @@
- 
- #if !defined WIN32_NATIVE
- # include <unistd.h>
-# if HAVE_LANGINFO_CODESET
-+# if HAVE_LANGINFO_CODESET && !(defined __ANDROID__)
- #  include <langinfo.h>
- # else
- #  if 0 /* see comment below */
-@@ -124,7 +124,7 @@ get_charset_aliases (void)
-   cp = charset_aliases;
-   if (cp == NULL)
-     {
-#if !(defined DARWIN7 || defined VMS || defined WIN32_NATIVE || defined __CYGWIN__)
-+#if !(defined DARWIN7 || defined VMS || defined WIN32_NATIVE || defined __CYGWIN__ || defined __ANDROID__)
-       const char *dir;
-       const char *base = "charset.alias";
-       char *file_name;
-@@ -338,6 +338,9 @@ get_charset_aliases (void)
-            "CP54936" "\0" "GB18030" "\0"
-            "CP65001" "\0" "UTF-8" "\0";
- # endif
-+# if defined __ANDROID__
-+      cp = "*" "\0" "UTF-8" "\0";
-+# endif
- #endif
- 
-       charset_aliases = cp;
-@@ -361,7 +364,7 @@ locale_charset (void)
-   const char *codeset;
-   const char *aliases;
- 
-#if !(defined WIN32_NATIVE || defined OS2)
-+#if !(defined WIN32_NATIVE || defined OS2 || defined __ANDROID__)
- 
- # if HAVE_LANGINFO_CODESET
- 
--- a/build/android/libiconv_stdio.patch
+++ b/build/android/libiconv_stdio.patch
@ -1,13 +0,0 @@
--- a/srclib/stdio.in.h	2011-08-07 15:42:06.000000000 +0200
-+++ b/srclib/stdio.in.h	2015-06-10 09:27:58.129056262 +0200
-@@ -695,8 +696,9 @@ _GL_CXXALIASWARN (gets);
- /* It is very rare that the developer ever has full control of stdin,
-    so any use of gets warrants an unconditional warning.  Assume it is
-    always declared, since it is required by C89.  */
-_GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead");
-+/*_GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead");*/
-+#define gets(a) fgets( a, sizeof(*(a)), stdin)
- #endif
-
-
-#if @GNULIB_OBSTACK_PRINTF@ || @GNULIB_OBSTACK_PRINTF_POSIX@
--- a/build/android/libvorbis-libogg-fpu.patch
+++ b/build/android/libvorbis-libogg-fpu.patch
@ -1,37 +0,0 @@
--- libvorbis-libogg-android/jni/libvorbis-jni/Android.mk.orig	2014-06-17 19:22:50.621559073 +0200
-+++ libvorbis-libogg-android/jni/libvorbis-jni/Android.mk	2014-06-17 19:38:20.641581140 +0200
-@@ -4,9 +4,6 @@
- 
- LOCAL_MODULE := vorbis-jni
- LOCAL_CFLAGS += -I$(LOCAL_PATH)/../include -fsigned-char
-ifeq ($(TARGET_ARCH),arm)
-	LOCAL_CFLAGS += -march=armv6 -marm -mfloat-abi=softfp -mfpu=vfp
-endif
- 
- LOCAL_SHARED_LIBRARIES := libogg libvorbis
- 
--- libvorbis-libogg-android/jni/libvorbis/Android.mk.orig	2014-06-17 19:22:39.077558797 +0200
-+++ libvorbis-libogg-android/jni/libvorbis/Android.mk	2014-06-17 19:38:52.121581887 +0200
-@@ -4,9 +4,6 @@
- 
- LOCAL_MODULE := libvorbis
- LOCAL_CFLAGS += -I$(LOCAL_PATH)/../include -ffast-math -fsigned-char
-ifeq ($(TARGET_ARCH),arm)
-	LOCAL_CFLAGS += -march=armv6 -marm -mfloat-abi=softfp -mfpu=vfp
-endif
- LOCAL_SHARED_LIBRARIES := libogg
- 
- LOCAL_SRC_FILES := \
--- libvorbis-libogg-android/jni/libogg/Android.mk.orig	2014-06-17 19:22:33.965558675 +0200
-+++ libvorbis-libogg-android/jni/libogg/Android.mk	2014-06-17 19:38:25.337581252 +0200
-@@ -4,10 +4,6 @@
- 
- LOCAL_MODULE := libogg
- LOCAL_CFLAGS += -I$(LOCAL_PATH)/../include -ffast-math -fsigned-char
-ifeq ($(TARGET_ARCH),arm)
-	LOCAL_CFLAGS += -march=armv6 -marm -mfloat-abi=softfp -mfpu=vfp
-endif
-
- 
- LOCAL_SRC_FILES := \
- 	bitwise.c \
--- a/build/android/openssl_arch.patch
+++ b/build/android/openssl_arch.patch
@ -1,11 +0,0 @@
--- openssl-1.0.1j/Configure.orig	2014-10-15 14:53:39.000000000 +0200
-+++ openssl-1.0.1j/Configure	2015-01-03 22:41:43.505749921 +0100
-@@ -407,6 +407,8 @@
- "android","gcc:-mandroid -I\$(ANDROID_DEV)/include -B\$(ANDROID_DEV)/lib -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
- "android-x86","gcc:-mandroid -I\$(ANDROID_DEV)/include -B\$(ANDROID_DEV)/lib -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:".eval{my $asm=${x86_elf_asm};$asm=~s/:elf/:android/;$asm}.":dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
- "android-armv7","gcc:-march=armv7-a -mandroid -I\$(ANDROID_DEV)/include -B\$(ANDROID_DEV)/lib -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${armv4_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-+"android-arm","gcc:-march=armv4 -mandroid -I\$(ANDROID_DEV)/include -B\$(ANDROID_DEV)/lib -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${armv4_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-+"android-mips32","gcc:-march=mips32 -mandroid -I\$(ANDROID_DEV)/include -B\$(ANDROID_DEV)/lib -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${mips32_asm}:o32:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
- 
- #### *BSD [do see comment about ${BSDthreads} above!]
- "BSD-generic32","gcc:-DTERMIOS -O3 -fomit-frame-pointer -Wall::${BSDthreads}:::BN_LLONG RC2_CHAR RC4_INDEX DES_INT DES_UNROLL:${no_asm}:dlfcn:bsd-gcc-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
--- a/build/android/project.properties
+++ b/build/android/project.properties
@ -1 +0,0 @@
-target=android-10
--- a/build/android/res/drawable-hdpi/irr_icon.png
+++ b/build/android/res/drawable-hdpi/irr_icon.png
--- a/build/android/res/drawable-ldpi/irr_icon.png
+++ b/build/android/res/drawable-ldpi/irr_icon.png
--- a/build/android/res/drawable-mdpi/irr_icon.png
+++ b/build/android/res/drawable-mdpi/irr_icon.png
--- a/build/android/res/drawable-xhdpi/irr_icon.png
+++ b/build/android/res/drawable-xhdpi/irr_icon.png
--- a/build/android/res/layout/assetcopy.xml
+++ b/build/android/res/layout/assetcopy.xml
@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    android:orientation="vertical" >
-
-    <ProgressBar
-        android:id="@+id/progressBar1"
-        style="?android:attr/progressBarStyleHorizontal"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center_vertical" />
-
-    <TextView
-        android:id="@+id/textView1"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_gravity="center_horizontal"
-        android:text="preparing media ..."
-        android:textAppearance="?android:attr/textAppearanceSmall" />
-
-</LinearLayout>
--- a/build/android/res/values/styles.xml
+++ b/build/android/res/values/styles.xml
@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-	<style name="Theme.Transparent" parent="android:Theme">
-		<item name="android:windowIsTranslucent">true</item>
-		<item name="android:windowBackground">@android:color/transparent</item>
-		<item name="android:windowContentOverlay">@null</item>
-		<item name="android:windowNoTitle">true</item>
-		<item name="android:windowIsFloating">true</item>
-		<item name="android:backgroundDimEnabled">false</item>
-	</style>
-</resources>
--- a/build/android/src/net/minetest/minetest/MinetestAssetCopy.java
+++ b/build/android/src/net/minetest/minetest/MinetestAssetCopy.java
@ -1,456 +0,0 @@
-package net.minetest.minetest;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.util.Vector;
-import java.util.Iterator;
-import java.lang.Object;
-
-import android.app.Activity;
-import android.content.res.AssetFileDescriptor;
-
-import android.os.AsyncTask;
-import android.os.Bundle;
-import android.os.Environment;
-import android.util.Log;
-import android.view.Display;
-import android.widget.ProgressBar;
-import android.widget.TextView;
-import android.graphics.Rect;
-import android.graphics.Paint;
-import android.text.TextPaint;
-
-public class MinetestAssetCopy extends Activity
-{
-	@Override
-	public void onCreate(Bundle savedInstanceState)
-	{
-		super.onCreate(savedInstanceState);
-		
-		setContentView(R.layout.assetcopy);
-		
-		m_ProgressBar = (ProgressBar) findViewById(R.id.progressBar1);
-		m_Filename = (TextView) findViewById(R.id.textView1);
-		
-		Display display = getWindowManager().getDefaultDisplay();
-		m_ProgressBar.getLayoutParams().width = (int) (display.getWidth() * 0.8);
-		m_ProgressBar.invalidate();
-		
-		/* check if there's already a copy in progress and reuse in case it is*/
-		MinetestAssetCopy prevActivity = 
-				(MinetestAssetCopy) getLastNonConfigurationInstance();
-		if(prevActivity!= null) {
-			m_AssetCopy = prevActivity.m_AssetCopy;
-		}
-		else {
-			m_AssetCopy = new copyAssetTask();
-			m_AssetCopy.execute();
-		}
-	}
-	
-	/* preserve asset copy background task to prevent restart of copying */
-	/* this way of doing it is not recommended for latest android version */
-	/* but the recommended way isn't available on android 2.x */
-	public Object onRetainNonConfigurationInstance()
-	{
-		return this;
-	}
-	
-	ProgressBar m_ProgressBar;
-	TextView m_Filename;
-	
-	copyAssetTask m_AssetCopy;
-	
-	private class copyAssetTask extends AsyncTask<String, Integer, String>
-	{
-		private long getFullSize(String filename)
-		{
-			long size = 0;
-			try {
-				InputStream src = getAssets().open(filename);
-				byte[] buf = new byte[4096];
-				
-				int len = 0;
-				while ((len = src.read(buf)) > 0)
-				{
-					size += len;
-				}
-			}
-			catch (IOException e)
-			{
-				e.printStackTrace();
-			}
-			return size;
-		}
-
-		@Override
-		protected String doInBackground(String... files)
-		{
-			m_foldernames  = new Vector<String>();
-			m_filenames    = new Vector<String>();
-			m_tocopy       = new Vector<String>();
-			m_asset_size_unknown = new Vector<String>();
-			String baseDir = 
-					Environment.getExternalStorageDirectory().getAbsolutePath()
-					+ "/";
-			
-			
-			// prepare temp folder
-			File TempFolder = new File(baseDir + "Minetest/tmp/");
-			
-			if (!TempFolder.exists())
-			{
-				TempFolder.mkdir();
-			}
-			else {
-				File[] todel = TempFolder.listFiles();
-				
-				for(int i=0; i < todel.length; i++)
-				{
-					Log.v("MinetestAssetCopy","deleting: " + todel[i].getAbsolutePath());
-					todel[i].delete();
-				}
-			}
-			
-			// add a .nomedia file
-			try {
-				OutputStream dst = new FileOutputStream(baseDir + "Minetest/.nomedia");
-				dst.close();
-			} catch (IOException e) {
-				Log.e("MinetestAssetCopy","Failed to create .nomedia file");
-				e.printStackTrace();
-			}
-			
-			
-			// build lists from prepared data
-			BuildFolderList();
-			BuildFileList();
-			
-			// scan filelist
-			ProcessFileList();
-			
-			// doing work
-			m_copy_started = true;
-			m_ProgressBar.setMax(m_tocopy.size());
-			
-			for (int i = 0; i < m_tocopy.size(); i++)
-			{
-				try
-				{
-					String filename = m_tocopy.get(i);
-					publishProgress(i);
-					
-					boolean asset_size_unknown = false;
-					long filesize = -1;
-					
-					if (m_asset_size_unknown.contains(filename))
-					{
-						File testme = new File(baseDir + "/" + filename);
-						
-						if(testme.exists())
-						{
-							filesize = testme.length();
-						}
-						asset_size_unknown = true;
-					}
-					
-					InputStream src;
-					try
-					{
-						src = getAssets().open(filename);
-					} catch (IOException e) {
-						Log.e("MinetestAssetCopy","Copying file: " + filename + " FAILED (not in assets)");
-						e.printStackTrace();
-						continue;
-					}
-					
-					// Transfer bytes from in to out
-					byte[] buf = new byte[1*1024];
-					int len = src.read(buf, 0, 1024);
-					
-					/* following handling is crazy but we need to deal with    */
-					/* compressed assets.Flash chips limited livetime due to   */
-					/* write operations, we can't allow large files to destroy */
-					/* users flash.                                            */
-					if (asset_size_unknown)
-					{
-						if ( (len > 0) && (len < buf.length) && (len == filesize))
-						{
-							src.close();
-							continue;
-						}
-						
-						if (len == buf.length)
-						{
-							src.close();
-							long size = getFullSize(filename);
-							if ( size == filesize)
-							{
-								continue;
-							}
-							src = getAssets().open(filename);
-							len = src.read(buf, 0, 1024);
-						}
-					}
-					if (len > 0)
-					{
-						int total_filesize = 0;
-						OutputStream dst;
-						try
-						{
-							dst = new FileOutputStream(baseDir + "/" + filename);
-						} catch (IOException e) {
-							Log.e("MinetestAssetCopy","Copying file: " + baseDir +
-							"/" + filename + " FAILED (couldn't open output file)");
-							e.printStackTrace();
-							src.close();
-							continue;
-						}
-						dst.write(buf, 0, len);
-						total_filesize += len;
-						
-						while ((len = src.read(buf)) > 0)
-						{
-							dst.write(buf, 0, len);
-							total_filesize += len;
-						}
-						
-						dst.close();
-						Log.v("MinetestAssetCopy","Copied file: " +
-									m_tocopy.get(i) + " (" + total_filesize +
-									" bytes)");
-					}
-					else if (len < 0)
-					{
-						Log.e("MinetestAssetCopy","Copying file: " +
-								m_tocopy.get(i) + " failed, size < 0");
-					}
-					src.close();
-				} 
-				catch (IOException e)
-				{
-					Log.e("MinetestAssetCopy","Copying file: " +
-							m_tocopy.get(i) + " failed");
-					e.printStackTrace();
-				}
-			}
-			return "";
-		}
-		
-		
-		/**
-		 * update progress bar
-		 */
-		protected void onProgressUpdate(Integer... progress)
-		{
-			
-			if (m_copy_started)
-			{
-				boolean shortened = false;
-				String todisplay = m_tocopy.get(progress[0]);
-				m_ProgressBar.setProgress(progress[0]);
-				
-				// make sure our text doesn't exceed our layout width
-				Rect bounds = new Rect();
-				Paint textPaint = m_Filename.getPaint();
-				textPaint.getTextBounds(todisplay, 0, todisplay.length(), bounds);
-				
-				while (bounds.width() > getResources().getDisplayMetrics().widthPixels * 0.7) {
-					if (todisplay.length() < 2) {
-						break;
-					}
-					todisplay = todisplay.substring(1);
-					textPaint.getTextBounds(todisplay, 0, todisplay.length(), bounds);
-					shortened = true;
-				}
-				
-				if (! shortened) {
-					m_Filename.setText(todisplay);
-				}
-				else {
-					m_Filename.setText(".." + todisplay);
-				}
-			}
-			else
-			{
-				boolean shortened = false;
-				String todisplay = m_Foldername;
-				String full_text = "scanning " + todisplay + " ...";
-				// make sure our text doesn't exceed our layout width
-				Rect bounds = new Rect();
-				Paint textPaint = m_Filename.getPaint();
-				textPaint.getTextBounds(full_text, 0, full_text.length(), bounds);
-				
-				while (bounds.width() > getResources().getDisplayMetrics().widthPixels * 0.7) {
-					if (todisplay.length() < 2) {
-						break;
-					}
-					todisplay = todisplay.substring(1);
-					full_text = "scanning " + todisplay + " ...";
-					textPaint.getTextBounds(full_text, 0, full_text.length(), bounds);
-					shortened = true;
-				}
-				
-				if (! shortened) {
-					m_Filename.setText(full_text);
-				}
-				else {
-					m_Filename.setText("scanning .." + todisplay + " ...");
-				}
-			}
-		}
-		
-		/**
-		 * check al files and folders in filelist
-		 */
-		protected void ProcessFileList()
-		{
-			String FlashBaseDir = 
-					Environment.getExternalStorageDirectory().getAbsolutePath();
-			
-			Iterator itr = m_filenames.iterator();
-			
-			while (itr.hasNext())
-			{
-				String current_path = (String) itr.next();
-				String FlashPath = FlashBaseDir + "/" + current_path;
-				
-				if (isAssetFolder(current_path))
-				{
-					/* store information and update gui */
-					m_Foldername = current_path;
-					publishProgress(0);
-					
-					/* open file in order to check if it's a folder */
-					File current_folder = new File(FlashPath);
-					if (!current_folder.exists())
-					 {
-						if (!current_folder.mkdirs())
-						{
-							Log.e("MinetestAssetCopy","\t failed create folder: " +
-									FlashPath);
-						}
-						else
-						{
-							Log.v("MinetestAssetCopy","\t created folder: " +
-									FlashPath);
-						}
-					}
-					
-					continue;
-				}
-				
-				/* if it's not a folder it's most likely a file */
-				boolean refresh = true;
-				
-				File testme = new File(FlashPath);
-				
-				long asset_filesize = -1;
-				long stored_filesize = -1;
-				
-				if (testme.exists())
-				{
-					try
-					{
-						AssetFileDescriptor fd = getAssets().openFd(current_path);
-						asset_filesize         = fd.getLength();
-						fd.close();
-					} 
-					catch (IOException e)
-					{
-						refresh = true;
-						m_asset_size_unknown.add(current_path);
-						Log.e("MinetestAssetCopy","Failed to open asset file \"" +
-								FlashPath + "\" for size check");
-					}
-					
-					stored_filesize = testme.length();
-					
-					if (asset_filesize == stored_filesize)
-					{
-						refresh = false;
-					}
-					
-				}
-				
-				if (refresh)
-				{
-					m_tocopy.add(current_path);
-				}
-			}
-		}
-		
-		/**
-		 * read list of folders prepared on package build
-		 */
-		protected void BuildFolderList()
-		{
-			try
-			{
-				InputStream is = getAssets().open("index.txt");
-				BufferedReader reader = new BufferedReader(new InputStreamReader(is));
-		
-				String line = reader.readLine();
-				while (line != null)
-				{
-					m_foldernames.add(line);
-					line = reader.readLine();
-				}
-				is.close();
-			} catch (IOException e1)
-			{
-				Log.e("MinetestAssetCopy","Error on processing index.txt");
-				e1.printStackTrace();
-			}
-		}
-		
-		/**
-		 * read list of asset files prepared on package build
-		 */
-		protected void BuildFileList()
-		{
-			long entrycount = 0;
-			try
-			{
-				InputStream is = getAssets().open("filelist.txt");
-				BufferedReader reader = new BufferedReader(new InputStreamReader(is));
-		
-				String line = reader.readLine();
-				while (line != null)
-				{
-					m_filenames.add(line);
-					line = reader.readLine();
-					entrycount ++;
-				}
-				is.close();
-			}
-			catch (IOException e1)
-			{
-				Log.e("MinetestAssetCopy","Error on processing filelist.txt");
-				e1.printStackTrace();
-			}
-		}
-		
-		protected void onPostExecute (String result)
-		{
-			finish();
-		}
-		
-		protected boolean isAssetFolder(String path)
-		{
-			return m_foldernames.contains(path);
-		}
-		
-		boolean m_copy_started = false;
-		String m_Foldername = "media";
-		Vector<String> m_foldernames;
-		Vector<String> m_filenames;
-		Vector<String> m_tocopy;
-		Vector<String> m_asset_size_unknown;
-	}
-}
--- a/build/android/src/net/minetest/minetest/MinetestTextEntry.java
+++ b/build/android/src/net/minetest/minetest/MinetestTextEntry.java
@ -1,91 +0,0 @@
-package net.minetest.minetest;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.os.Bundle;
-import android.text.InputType;
-import android.util.Log;
-import android.view.KeyEvent;
-import android.view.View;
-import android.view.View.OnKeyListener;
-import android.widget.EditText;
-
-public class MinetestTextEntry extends Activity {
-	public AlertDialog mTextInputDialog;
-	public EditText mTextInputWidget;
-	
-	private final int MultiLineTextInput              = 1;
-	private final int SingleLineTextInput             = 2;
-	private final int SingleLinePasswordInput         = 3;
-	
-	@Override
-	public void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		
-		Bundle b = getIntent().getExtras();
-		String acceptButton = b.getString("EnterButton");
-		String hint         = b.getString("hint");
-		String current      = b.getString("current");
-		int    editType     = b.getInt("editType");
-		
-		AlertDialog.Builder builder = new AlertDialog.Builder(this);
-		mTextInputWidget = new EditText(this);
-		mTextInputWidget.setHint(hint);
-		mTextInputWidget.setText(current);
-		mTextInputWidget.setMinWidth(300);
-		if (editType == SingleLinePasswordInput) {
-			mTextInputWidget.setInputType(InputType.TYPE_CLASS_TEXT | 
-					InputType.TYPE_TEXT_VARIATION_PASSWORD);
-		}
-		else {
-			mTextInputWidget.setInputType(InputType.TYPE_CLASS_TEXT);
-		}
-		
-		
-		builder.setView(mTextInputWidget);
-		
-		if (editType == MultiLineTextInput) {
-			builder.setPositiveButton(acceptButton, new DialogInterface.OnClickListener() {
-				public void onClick(DialogInterface dialog, int whichButton) 
-				{ pushResult(mTextInputWidget.getText().toString()); }
-				});
-		}
-		
-		builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
-			public void onCancel(DialogInterface dialog) {
-				cancelDialog();
-			}
-		});
-		
-		mTextInputWidget.setOnKeyListener(new OnKeyListener() {
-			@Override
-			public boolean onKey(View view, int KeyCode, KeyEvent event) {
-				if ( KeyCode == KeyEvent.KEYCODE_ENTER){
-
-					pushResult(mTextInputWidget.getText().toString());
-					return true;
-				}
-				return false;
-			}
-		});
-		
-		mTextInputDialog = builder.create();
-		mTextInputDialog.show();
-	}
-	
-	public void pushResult(String text) {
-		Intent resultData = new Intent();
-		resultData.putExtra("text", text);
-		setResult(Activity.RESULT_OK,resultData);
-		mTextInputDialog.dismiss();
-		finish();
-	}
-	
-	public void cancelDialog() {
-		setResult(Activity.RESULT_CANCELED);
-		mTextInputDialog.dismiss();
-		finish();
-	}
-}
--- a/build/android/src/net/minetest/minetest/MtNativeActivity.java
+++ b/build/android/src/net/minetest/minetest/MtNativeActivity.java
@ -1,100 +0,0 @@
-package net.minetest.minetest;
-
-import android.app.NativeActivity;
-import android.content.Intent;
-import android.os.Bundle;
-import android.util.Log;
-import android.view.WindowManager;
-
-public class MtNativeActivity extends NativeActivity {
-	@Override
-	public void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		m_MessagReturnCode = -1;
-		m_MessageReturnValue = "";
-
-	}
-
-	@Override
-	public void onDestroy() {
-		super.onDestroy();
-	}
-
-
-	public void copyAssets() {
-		Intent intent = new Intent(this, MinetestAssetCopy.class);
-		startActivity(intent);
-	}
-
-	public void showDialog(String acceptButton, String hint, String current,
-			int editType) {
-
-		Intent intent = new Intent(this, MinetestTextEntry.class);
-		Bundle params = new Bundle();
-		params.putString("acceptButton", acceptButton);
-		params.putString("hint", hint);
-		params.putString("current", current);
-		params.putInt("editType", editType);
-		intent.putExtras(params);
-		startActivityForResult(intent, 101);
-		m_MessageReturnValue = "";
-		m_MessagReturnCode   = -1;
-	}
-
-	public static native void putMessageBoxResult(String text);
-
-	/* ugly code to workaround putMessageBoxResult not beeing found */
-	public int getDialogState() {
-		return m_MessagReturnCode;
-	}
-
-	public String getDialogValue() {
-		m_MessagReturnCode = -1;
-		return m_MessageReturnValue;
-	}
-
-	public float getDensity() {
-		return getResources().getDisplayMetrics().density;
-	}
-
-	public int getDisplayWidth() {
-		return getResources().getDisplayMetrics().widthPixels;
-	}
-
-	public int getDisplayHeight() {
-		return getResources().getDisplayMetrics().heightPixels;
-	}
-
-	@Override
-	protected void onActivityResult(int requestCode, int resultCode,
-			Intent data) {
-		if (requestCode == 101) {
-			if (resultCode == RESULT_OK) {
-				String text = data.getStringExtra("text");
-				m_MessagReturnCode = 0;
-				m_MessageReturnValue = text;
-			}
-			else {
-				m_MessagReturnCode = 1;
-			}
-		}
-	}
-
-	static {
-		System.loadLibrary("openal");
-		System.loadLibrary("ogg");
-		System.loadLibrary("vorbis");
-		System.loadLibrary("ssl");
-		System.loadLibrary("crypto");
-		System.loadLibrary("gmp");
-		System.loadLibrary("iconv");
-
-		// We don't have to load libminetest.so ourselves,
-		// but if we do, we get nicer logcat errors when
-		// loading fails.
-		System.loadLibrary("minetest");
-	}
-
-	private int m_MessagReturnCode;
-	private String m_MessageReturnValue;
-}
--- a/builtin/mainmenu/init.lua
+++ b/builtin/mainmenu/init.lua
@ -41,7 +41,6 @@ dofile(menupath .. DIR_DELIM .. "dlg_config_world.lua")
 dofile(menupath .. DIR_DELIM .. "tab_credits.lua")
 dofile(menupath .. DIR_DELIM .. "tab_mods.lua")
 dofile(menupath .. DIR_DELIM .. "tab_settings.lua")
-if PLATFORM ~= "Android" then
 dofile(menupath .. DIR_DELIM .. "dlg_create_world.lua")
 dofile(menupath .. DIR_DELIM .. "dlg_delete_mod.lua")
 dofile(menupath .. DIR_DELIM .. "dlg_delete_world.lua")
@ -51,9 +50,6 @@ if PLATFORM ~= "Android" then
 dofile(menupath .. DIR_DELIM .. "tab_singleplayer.lua")
 dofile(menupath .. DIR_DELIM .. "tab_texturepacks.lua")
 dofile(menupath .. DIR_DELIM .. "textures.lua")
-else
-	dofile(menupath .. DIR_DELIM .. "tab_simple_main.lua")
-end

 --------------------------------------------------------------------------------
 local function main_event_handler(tabview, event)
@ -69,7 +65,6 @@ local function init_globals()
 	gamedata.worldindex = 0


-	if PLATFORM ~= "Android" then
 	menudata.worldlist = filterlist.create(
 		core.get_worlds,
 		compare_worlds,
@ -92,49 +87,15 @@ local function init_globals()
 	end

 	mm_texture.init()
-	else
-		local world_list = core.get_worlds()
-
-		local found_singleplayerworld = false
-
-		for i,world in pairs(world_list) do
-			if world.name == "singleplayerworld" then
-				found_singleplayerworld = true
-				gamedata.worldindex = i
-				break
-			end
-		end
-
-		if not found_singleplayerworld then
-			core.create_world("singleplayerworld", 1)
-
-			local world_list = core.get_worlds()
-
-			for i,world in pairs(world_list) do
-				if world.name == "singleplayerworld" then
-					gamedata.worldindex = i
-					break
-				end
-			end
-		end
-	end
 	
 	-- Create main tabview
 	local tv_main = tabview_create("maintab",{x=12,y=5.2},{x=0,y=0})
-	if PLATFORM ~= "Android" then
 	tv_main:set_autosave_tab(true)
-	end
-	if PLATFORM ~= "Android" then
 	tv_main:add(tab_singleplayer)
 	tv_main:add(tab_multiplayer)
 	tv_main:add(tab_server)
-	else
-		tv_main:add(tab_simple_main)
-	end
 	tv_main:add(tab_settings)
-	if PLATFORM ~= "Android" then
 	tv_main:add(tab_texturepacks)
-	end
 	tv_main:add(tab_mods)
 	tv_main:add(tab_credits)

@ -142,18 +103,13 @@ local function init_globals()

 	tv_main:set_fixed_size(false)

-	if not (PLATFORM == "Android") then
 	tv_main:set_tab(core.setting_get("maintab_LAST"))
-	end
+	
 	ui.set_default("maintab")
 	tv_main:show()

 	-- Create modstore ui
-	if PLATFORM == "Android" then
-		modstore.init({x=12, y=6}, 3, 2)
-	else
 	modstore.init({x=12, y=8}, 4, 3)
-	end
 	
 	ui.update()

--- a/builtin/mainmenu/init_simple.lua
+++ b/builtin/mainmenu/init_simple.lua
@ -1,4 +0,0 @@
-- helper file to be able to debug the simple menu on PC
-- without messing around with actual menu code!
-PLATFORM="Android"
-dofile("builtin/mainmenu/init.lua")
--- a/cmake/Modules/FindOpenGLES2.cmake
+++ b/cmake/Modules/FindOpenGLES2.cmake
@ -16,7 +16,7 @@
 #  EGL_INCLUDE_DIR  - the EGL include directory
 #  EGL_LIBRARIES    - Link these to use EGL

-# Win32, Apple, and Android are not tested!
+# Win32 and Apple are not tested!
 # Linux tested and works

 if(WIN32)
@ -51,7 +51,6 @@ else()
 			/usr/lib
 	)

-	if(NOT BUILD_ANDROID)
 	find_path(EGL_INCLUDE_DIR EGL/egl.h
 		PATHS /usr/openwin/share/include
 			/opt/graphics/OpenGL/include
@ -80,22 +79,14 @@ else()
 		endif()
 	endif()
 endif()
-endif()

 set(OPENGLES2_LIBRARIES ${OPENGLES2_LIBRARIES} ${OPENGLES2_LIBRARY})

-if(BUILD_ANDROID)
-	if(OPENGLES2_LIBRARY)
-		set(EGL_LIBRARIES)
-		set(OPENGLES2_FOUND TRUE)
-	endif()
-else()
 if(OPENGLES2_LIBRARY AND EGL_LIBRARY)
 	set(OPENGLES2_LIBRARIES ${OPENGLES2_LIBRARY} ${OPENGLES2_LIBRARIES})
 	set(EGL_LIBRARIES ${EGL_LIBRARY} ${EGL_LIBRARIES})
 	set(OPENGLES2_FOUND TRUE)
 endif()
-endif()

 mark_as_advanced(
 	OPENGLES2_INCLUDE_DIR
@ -109,4 +100,3 @@ if(OPENGLES2_FOUND)
 else()
 	set(OPENGLES2_LIBRARIES "")
 endif()
-
--- a/doc/README.android
+++ b/doc/README.android
@ -1,130 +0,0 @@
-Minetest Android port
-=====================
-Date: 2014 06 28
-
-Controls
--------
-The Android port doesn't support everything you can do on PC due to the
-limited capabilities of common devices. What can be done is described
-below:
-
-While you're playing the game normally (that is, no menu or inventory is
-shown), the following controls are available:
-* Look around: touch screen and slide finger
-* double tap: place a node or use selected item
-* long tap: dig node
-* touch shown buttons: press button
-* Buttons:
-** left upper corner: chat
-** right lower corner: jump
-** right lower corner: crouch
-** left lower corner: walk/step...
-   left up right
-       down
-** left lower corner: display inventory
-
-When a menu or inventory is displayed:
-* double tap outside menu area: close menu
-* tap on an item stack: select that stack
-* tap on an empty slot: if you selected a stack already, that stack is placed here
-* drag and drop: touch stack and hold finger down, move the stack to another
-  slot, tap another finger while keeping first finger on screen
-  --> places a single item from dragged stack into current (first touched) slot
-
-Special settings
----------------
-There are some settings especially useful for Android users. Minetest's config
-file can usually be found at /mnt/sdcard/Minetest.
-
-* gui_scaling: this is a user-specified scaling factor for the GUI- In case
-               main menu is too big or small on your device, try changing this
-               value.
-* inventory_image_hack: if your inventory items are messed up, try setting
-               this to true
-
-Known issues
------------
-Not all issues are fixed by now:
-
-* Unable to exit from volume menu -- don't use the volume menu, use Android's
-  volume controls instead.
-* 512 MB RAM seems to be inadequate -- this depends on the server you join.
-  Try to play on more lightweight servers.
-
-Versioning
----------
-Android version numbers are 4 digits instead of Minetest's 3 digits.  The last
-number of Android's version represents the Android internal version code. This
-version code is strictly incremental. It's incremented for each official
-Minetest Android build.
-
-E.g. prerelease Minetest Android builds have been 0.4.9.3, while the first
-official version most likely will be 0.4.10.4
-
-Requirements
------------
-
-In order to build, your PC has to be set up to build Minetest in the usual
-manner (see the regular Minetest documentation for how to get this done).
-In addition to what is required for Minetest in general, you will need the
-following software packages. The version number in parenthesis denotes the
-version that was tested at the time this README was drafted; newer/older
-versions may or may not work.
-
-* android SDK (x86_64 20131030)
-* android NDK (r9d)
-* wget (1.13.4)
-
-Additionally, you'll need to have an Internet connection available on the
-build system, as the Android build will download some source packages.
-
-Build
-----
-
-Debug build:
-* Enter "build/android" subdirectory
-* Execute "make"
-* Answer the questions about where SDK and NDK are located on your filesystem
-* Wait for build to finish
-
-After the build is finished, the resulting apk can be fond in
-build/android/bin/. It will be called Minetest-debug.apk
-
-Release build:
-
-* In order to make a release build you'll have to have a keystore setup to sign
-  the resulting apk package. How this is done is not part of this README. There
-  are different tutorials on the web explaining how to do it
-  - choose one yourself.
-
-* Once your keystore is setup, enter build/android subdirectory and create a new
-  file "ant.properties" there. Add following lines to that file:
-  
-  > key.store=<path to your keystore>
-  > key.alias=Minetest
-
-* Execute "make release"
-* Enter your keystore as well as your Mintest key password once asked. Be
-  careful it's shown on console in clear text!
-* The result can be found at "bin/Minetest-release.apk"
-
-Other things that may be nice to know
------------
-* The environment for Android development tools is saved within Android build
-  build folder. If you want direct access to it do:
-  
-  > make envpaths
-  > . and_env
-  
-  After you've done this you'll have your path and path variables set correct
-  to use adb and all other Android development tools
-
-* You can build a single dependency by calling make and the dependency's name,
-  e.g.:
-
-  > make irrlicht
-
-* You can completely cleanup a dependency by calling make and the "clean" target,
-  e.g.:
-
-  > make clean_irrlicht
--- a/src/areastore.h
+++ b/src/areastore.h
@ -31,9 +31,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <istream>
 #include "util/container.h"
 #include "util/numeric.h"
-#ifndef ANDROID
 #include "cmake_config.h"
-#endif
 #if USE_SPATIAL
 	#include <spatialindex/SpatialIndex.h>
 	#include "util/serialize.h"
--- a/src/client/clientlauncher.cpp
+++ b/src/client/clientlauncher.cpp
@ -493,9 +493,7 @@ void ClientLauncher::main_menu(MainMenuData *menudata)
 	infostream << "Waited for other menus" << std::endl;

 	// Cursor can be non-visible when coming from the game
-#ifndef ANDROID
 	device->getCursorControl()->setVisible(true);
-#endif

 	/* show main menu */
 	GUIEngine mymenu(device, guiroot, &g_menumgr, smgr, menudata, *kill);
@ -543,11 +541,6 @@ bool ClientLauncher::create_engine_device()
 	params.Vsync         = vsync;
 	params.EventReceiver = receiver;
 	params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
-#ifdef __ANDROID__
-	params.PrivateData = porting::app_global;
-	params.OGLES2ShaderPath = std::string(porting::path_user + DIR_DELIM +
-			"media" + DIR_DELIM + "Shaders" + DIR_DELIM).c_str();
-#endif

 	device = createDeviceEx(params);

--- a/src/client/tile.cpp
+++ b/src/client/tile.cpp
@ -41,10 +41,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "nodedef.h"


-#ifdef __ANDROID__
-#include <GLES/gl.h>
-#endif
-
 /*
 	A cache from texture name to texture path
 */
@ -621,9 +617,6 @@ u32 TextureSource::generateTexture(const std::string &name)
 	video::ITexture *tex = NULL;

 	if (img != NULL) {
-#ifdef __ANDROID__
-		img = Align2Npot2(img, driver);
-#endif
 		// Create texture from resulting image
 		tex = driver->addTexture(name.c_str(), img);
 		guiScalingCache(io::path(name.c_str()), driver, img);
@ -724,11 +717,7 @@ void TextureSource::rebuildImagesAndTextures()
 	for (u32 i=0; i<m_textureinfo_cache.size(); i++){
 		TextureInfo *ti = &m_textureinfo_cache[i];
 		video::IImage *img = generateImage(ti->name);
-#ifdef __ANDROID__
-		img = Align2Npot2(img, driver);
-		sanity_check(img->getDimension().Height == npot2(img->getDimension().Height));
-		sanity_check(img->getDimension().Width == npot2(img->getDimension().Width));
-#endif
+
 		// Create texture from resulting image
 		video::ITexture *t = NULL;
 		if (img) {
@ -751,128 +740,6 @@ video::ITexture* TextureSource::generateTextureFromMesh(
 	video::IVideoDriver *driver = m_device->getVideoDriver();
 	sanity_check(driver);

-#ifdef __ANDROID__
-	const GLubyte* renderstr = glGetString(GL_RENDERER);
-	std::string renderer((char*) renderstr);
-
-	// use no render to texture hack
-	if (
-		(renderer.find("Adreno") != std::string::npos) ||
-		(renderer.find("Mali") != std::string::npos) ||
-		(renderer.find("Immersion") != std::string::npos) ||
-		(renderer.find("Tegra") != std::string::npos) ||
-		g_settings->getBool("inventory_image_hack")
-		) {
-		// Get a scene manager
-		scene::ISceneManager *smgr_main = m_device->getSceneManager();
-		sanity_check(smgr_main);
-		scene::ISceneManager *smgr = smgr_main->createNewSceneManager();
-		sanity_check(smgr);
-
-		const float scaling = 0.2;
-
-		scene::IMeshSceneNode* meshnode =
-				smgr->addMeshSceneNode(params.mesh, NULL,
-						-1, v3f(0,0,0), v3f(0,0,0),
-						v3f(1.0 * scaling,1.0 * scaling,1.0 * scaling), true);
-		meshnode->setMaterialFlag(video::EMF_LIGHTING, true);
-		meshnode->setMaterialFlag(video::EMF_ANTI_ALIASING, true);
-		meshnode->setMaterialFlag(video::EMF_TRILINEAR_FILTER, m_setting_trilinear_filter);
-		meshnode->setMaterialFlag(video::EMF_BILINEAR_FILTER, m_setting_bilinear_filter);
-		meshnode->setMaterialFlag(video::EMF_ANISOTROPIC_FILTER, m_setting_anisotropic_filter);
-
-		scene::ICameraSceneNode* camera = smgr->addCameraSceneNode(0,
-				params.camera_position, params.camera_lookat);
-		// second parameter of setProjectionMatrix (isOrthogonal) is ignored
-		camera->setProjectionMatrix(params.camera_projection_matrix, false);
-
-		smgr->setAmbientLight(params.ambient_light);
-		smgr->addLightSceneNode(0,
-				params.light_position,
-				params.light_color,
-				params.light_radius*scaling);
-
-		core::dimension2d<u32> screen = driver->getScreenSize();
-
-		// Render scene
-		driver->beginScene(true, true, video::SColor(0,0,0,0));
-		driver->clearZBuffer();
-		smgr->drawAll();
-
-		core::dimension2d<u32> partsize(screen.Width * scaling,screen.Height * scaling);
-
-		irr::video::IImage* rawImage =
-				driver->createImage(irr::video::ECF_A8R8G8B8, partsize);
-
-		u8* pixels = static_cast<u8*>(rawImage->lock());
-		if (!pixels)
-		{
-			rawImage->drop();
-			return NULL;
-		}
-
-		core::rect<s32> source(
-				screen.Width /2 - (screen.Width  * (scaling / 2)),
-				screen.Height/2 - (screen.Height * (scaling / 2)),
-				screen.Width /2 + (screen.Width  * (scaling / 2)),
-				screen.Height/2 + (screen.Height * (scaling / 2))
-			);
-
-		glReadPixels(source.UpperLeftCorner.X, source.UpperLeftCorner.Y,
-				partsize.Width, partsize.Height, GL_RGBA,
-				GL_UNSIGNED_BYTE, pixels);
-
-		driver->endScene();
-
-		// Drop scene manager
-		smgr->drop();
-
-		unsigned int pixelcount = partsize.Width*partsize.Height;
-
-		u8* runptr = pixels;
-		for (unsigned int i=0; i < pixelcount; i++) {
-
-			u8 B = *runptr;
-			u8 G = *(runptr+1);
-			u8 R = *(runptr+2);
-			u8 A = *(runptr+3);
-
-			//BGRA -> RGBA
-			*runptr = R;
-			runptr ++;
-			*runptr = G;
-			runptr ++;
-			*runptr = B;
-			runptr ++;
-			*runptr = A;
-			runptr ++;
-		}
-
-		video::IImage* inventory_image =
-				driver->createImage(irr::video::ECF_A8R8G8B8, params.dim);
-
-		rawImage->copyToScaling(inventory_image);
-		rawImage->drop();
-
-		guiScalingCache(io::path(params.rtt_texture_name.c_str()), driver, inventory_image);
-
-		video::ITexture *rtt = driver->addTexture(params.rtt_texture_name.c_str(), inventory_image);
-		inventory_image->drop();
-
-		if (rtt == NULL) {
-			errorstream << "TextureSource::generateTextureFromMesh(): failed to recreate texture from image: " << params.rtt_texture_name << std::endl;
-			return NULL;
-		}
-
-		driver->makeColorKeyTexture(rtt, v2s32(0,0));
-
-		if (params.delete_texture_on_shutdown)
-			m_texture_trash.push_back(rtt);
-
-		return rtt;
-	}
-#endif
-
 	if (driver->queryFeature(video::EVDF_RENDER_TO_TARGET) == false)
 	{
 		static bool warned = false;
@ -1049,57 +916,6 @@ video::IImage* TextureSource::generateImage(const std::string &name)
 	return baseimg;
 }

-#ifdef __ANDROID__
-#include <GLES/gl.h>
-/**
- * Check and align image to npot2 if required by hardware
- * @param image image to check for npot2 alignment
- * @param driver driver to use for image operations
- * @return image or copy of image aligned to npot2
- */
-video::IImage * Align2Npot2(video::IImage * image,
-		video::IVideoDriver* driver)
-{
-	if (image == NULL) {
-		return image;
-	}
-
-	core::dimension2d<u32> dim = image->getDimension();
-
-	std::string extensions = (char*) glGetString(GL_EXTENSIONS);
-	if (extensions.find("GL_OES_texture_npot") != std::string::npos) {
-		return image;
-	}
-
-	unsigned int height = npot2(dim.Height);
-	unsigned int width  = npot2(dim.Width);
-
-	if ((dim.Height == height) &&
-			(dim.Width == width)) {
-		return image;
-	}
-
-	if (dim.Height > height) {
-		height *= 2;
-	}
-
-	if (dim.Width > width) {
-		width *= 2;
-	}
-
-	video::IImage *targetimage =
-			driver->createImage(video::ECF_A8R8G8B8,
-					core::dimension2d<u32>(width, height));
-
-	if (targetimage != NULL) {
-		image->copyToScaling(targetimage);
-	}
-	image->drop();
-	return targetimage;
-}
-
-#endif
-
 bool TextureSource::generateImagePart(std::string part_of_name,
 		video::IImage *& baseimg)
 {
@ -1110,9 +926,6 @@ bool TextureSource::generateImagePart(std::string part_of_name,
 	if (part_of_name.size() == 0 || part_of_name[0] != '[')
 	{
 		video::IImage *image = m_sourcecache.getOrLoad(part_of_name, m_device);
-#ifdef __ANDROID__
-		image = Align2Npot2(image, driver);
-#endif
 		if (image == NULL) {
 			if (part_of_name != "") {
 				if (part_of_name.find("_normal.png") == std::string::npos){
@ -1431,17 +1244,6 @@ bool TextureSource::generateImagePart(std::string part_of_name,
 				return true;
 			}

-#ifdef __ANDROID__
-			assert(img_top->getDimension().Height == npot2(img_top->getDimension().Height));
-			assert(img_top->getDimension().Width == npot2(img_top->getDimension().Width));
-
-			assert(img_left->getDimension().Height == npot2(img_left->getDimension().Height));
-			assert(img_left->getDimension().Width == npot2(img_left->getDimension().Width));
-
-			assert(img_right->getDimension().Height == npot2(img_right->getDimension().Height));
-			assert(img_right->getDimension().Width == npot2(img_right->getDimension().Width));
-#endif
-
 			// Create textures from images
 			video::ITexture *texture_top = driver->addTexture(
 					(imagename_top + "__temp__").c_str(), img_top);
--- a/src/client/tile.h
+++ b/src/client/tile.h
@ -144,10 +144,6 @@ public:

 IWritableTextureSource* createTextureSource(IrrlichtDevice *device);

-#ifdef __ANDROID__
-video::IImage * Align2Npot2(video::IImage * image, video::IVideoDriver* driver);
-#endif
-
 enum MaterialType{
 	TILE_MATERIAL_BASIC,
 	TILE_MATERIAL_ALPHA,
--- a/src/config.h
+++ b/src/config.h
@ -12,16 +12,6 @@

 #if defined USE_CMAKE_CONFIG_H
 	#include "cmake_config.h"
-#elif defined (__ANDROID__) || defined (ANDROID)
-	#define PROJECT_NAME "minetest"
-	#define PROJECT_NAME_C "Minetest"
-	#define STATIC_SHAREDIR ""
-	#include "android_version.h"
-	#ifdef NDEBUG
-		#define BUILD_TYPE "Release"
-	#else
-		#define BUILD_TYPE "Debug"
-	#endif
 #else
 	#ifdef NDEBUG
 		#define BUILD_TYPE "Release"
--- a/src/database-sqlite3.cpp
+++ b/src/database-sqlite3.cpp
@ -128,11 +128,7 @@ void Database_SQLite3::verifyDatabase()
 	PREPARE_STATEMENT(begin, "BEGIN");
 	PREPARE_STATEMENT(end, "COMMIT");
 	PREPARE_STATEMENT(read, "SELECT `data` FROM `blocks` WHERE `pos` = ? LIMIT 1");
-#ifdef __ANDROID__
-	PREPARE_STATEMENT(write,  "INSERT INTO `blocks` (`pos`, `data`) VALUES (?, ?)");
-#else
 	PREPARE_STATEMENT(write, "REPLACE INTO `blocks` (`pos`, `data`) VALUES (?, ?)");
-#endif
 	PREPARE_STATEMENT(delete, "DELETE FROM `blocks` WHERE `pos` = ?");
 	PREPARE_STATEMENT(list, "SELECT `pos` FROM `blocks`");

@ -166,19 +162,6 @@ bool Database_SQLite3::saveBlock(const v3s16 &pos, const std::string &data)
 {
 	verifyDatabase();

-#ifdef __ANDROID__
-	/**
-	 * Note: For some unknown reason SQLite3 fails to REPLACE blocks on Android,
-	 * deleting them and then inserting works.
-	 */
-	bindPos(m_stmt_read, pos);
-
-	if (sqlite3_step(m_stmt_read) == SQLITE_ROW) {
-		deleteBlock(pos);
-	}
-	sqlite3_reset(m_stmt_read);
-#endif
-
 	bindPos(m_stmt_write, pos);
 	SQLOK(sqlite3_bind_blob(m_stmt_write, 2, data.data(), data.size(), NULL));

--- a/src/defaultsettings.cpp
+++ b/src/defaultsettings.cpp
@ -333,39 +333,7 @@ void set_default_settings(Settings *settings)

 	settings->setDefault("language", "");

-#ifdef __ANDROID__
-	settings->setDefault("screenW", "0");
-	settings->setDefault("screenH", "0");
-	settings->setDefault("enable_shaders", "false");
-	settings->setDefault("fullscreen", "true");
-	settings->setDefault("enable_particles", "false");
-	settings->setDefault("video_driver", "ogles1");
-	settings->setDefault("touchtarget", "true");
-	settings->setDefault("TMPFolder","/sdcard/" PROJECT_NAME_C "/tmp/");
-	settings->setDefault("touchscreen_threshold","20");
-	settings->setDefault("smooth_lighting", "false");
-	settings->setDefault("max_simultaneous_block_sends_per_client", "3");
-	settings->setDefault("emergequeue_limit_diskonly", "8");
-	settings->setDefault("emergequeue_limit_generate", "8");
-	settings->setDefault("preload_item_visuals", "false");
-
-	settings->setDefault("viewing_range_nodes_max", "50");
-	settings->setDefault("viewing_range_nodes_min", "20");
-	settings->setDefault("inventory_image_hack", "false");
-
-	//check for device with small screen
-	float x_inches = ((double) porting::getDisplaySize().X /
-			(160 * porting::getDisplayDensity()));
-	if (x_inches  < 3.5) {
-		settings->setDefault("hud_scaling", "0.6");
-	}
-	else if (x_inches < 4.5) {
-		settings->setDefault("hud_scaling", "0.7");
-	}
-	settings->setDefault("curl_verify_cert","false");
-#else
 	settings->setDefault("screen_dpi", "72");
-#endif
 }

 void override_default_settings(Settings *settings, Settings *from)
--- a/src/filesys.cpp
+++ b/src/filesys.cpp
@ -375,11 +375,7 @@ std::string TempPath()
 		compatible with lua's os.tmpname which under the default
 		configuration hardcodes mkstemp("/tmp/lua_XXXXXX").
 	*/
-#ifdef __ANDROID__
-	return DIR_DELIM "sdcard" DIR_DELIM PROJECT_NAME DIR_DELIM "tmp";
-#else
 	return DIR_DELIM "tmp";
-#endif
 }

 #endif
--- a/src/game.cpp
+++ b/src/game.cpp
@ -1036,11 +1036,7 @@ static inline void create_formspec_menu(GUIFormSpecMenu **cur_formspec,
 	}
 }

-#ifdef __ANDROID__
-#define SIZE_TAG "size[11,5.5]"
-#else
 #define SIZE_TAG "size[11,5.5,true]" // Fixed size on desktop
-#endif

 static void show_chat_menu(GUIFormSpecMenu **cur_formspec,
 		InventoryManager *invmgr, IGameDef *gamedef,
@ -1090,21 +1086,6 @@ static void show_pause_menu(GUIFormSpecMenu **cur_formspec,
 		IWritableTextureSource *tsrc, IrrlichtDevice *device,
 		bool singleplayermode)
 {
-#ifdef __ANDROID__
-	std::string control_text = strgettext("Default Controls:\n"
-		"No menu visible:\n"
-		"- single tap: button activate\n"
-		"- double tap: place/use\n"
-		"- slide finger: look around\n"
-		"Menu/Inventory visible:\n"
-		"- double tap (outside):\n"
-		" -->close\n"
-		"- touch stack, touch slot:\n"
-		" --> move stack\n"
-		"- touch&drag, tap 2nd finger\n"
-		" --> place single item to slot\n"
-		);
-#else
 	std::string control_text = strgettext("Default Controls:\n"
 		"- WASD: move\n"
 		"- Space: jump/climb\n"
@ -1117,7 +1098,6 @@ static void show_pause_menu(GUIFormSpecMenu **cur_formspec,
 		"- Mouse wheel: select item\n"
 		"- T: chat\n"
 		);
-#endif

 	float ypos = singleplayermode ? 0.5 : 0.1;
 	std::ostringstream os;
@ -1131,12 +1111,11 @@ static void show_pause_menu(GUIFormSpecMenu **cur_formspec,
 		   << strgettext("Change Password") << "]";
 	}

-#ifndef __ANDROID__
 	os		<< "button_exit[4," << (ypos++) << ";3,0.5;btn_sound;"
 			<< strgettext("Sound Volume") << "]";
 	os		<< "button_exit[4," << (ypos++) << ";3,0.5;btn_key_config;"
 			<< strgettext("Change Keys")  << "]";
-#endif
+
 	os		<< "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_menu;"
 			<< strgettext("Exit to Menu") << "]";
 	os		<< "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_os;"
@ -1638,11 +1617,6 @@ private:
 	bool m_cache_enable_fog;
 	f32  m_cache_mouse_sensitivity;
 	f32  m_repeat_right_click_time;
-
-#ifdef __ANDROID__
-	bool m_cache_hold_aux1;
-#endif
-
 };

 Game::Game() :
@ -1684,11 +1658,6 @@ Game::Game() :
 		&settingChangedCallback, this);

 	readSettings();
-
-#ifdef __ANDROID__
-	m_cache_hold_aux1 = false;	// This is initialised properly later
-#endif
-
 }


@ -1813,11 +1782,6 @@ void Game::run()

 	set_light_table(g_settings->getFloat("display_gamma"));

-#ifdef __ANDROID__
-	m_cache_hold_aux1 = g_settings->getBool("fast_move")
-			&& client->checkPrivilege("fast");
-#endif
-
 	while (device->run() && !(*kill || g_gamecallback->shutdown_requested)) {

 		/* Must be called immediately after a device->run() call because it
@ -2586,12 +2550,6 @@ void Game::processUserInput(VolatileRunFlags *flags,
 		g_touchscreengui->step(dtime);
 	}

-#endif
-#ifdef __ANDROID__
-
-	if (current_formspec != 0)
-		current_formspec->getAndroidUIInput();
-
 #endif

 	// Increase timer for double tap of "keymap_jump"
@ -2824,9 +2782,6 @@ void Game::toggleFast(float *statustext_time)
 	if (fast_move && !has_fast_privs)
 		statustext += L" (note: no 'fast' privilege)";

-#ifdef __ANDROID__
-	m_cache_hold_aux1 = fast_move && has_fast_privs;
-#endif
 }


@ -3046,13 +3001,11 @@ void Game::updateCameraDirection(CameraOrientation *cam,
 {
 	if ((device->isWindowActive() && noMenuActive()) || random_input) {

-#ifndef __ANDROID__
 		if (!random_input) {
 			// Mac OSX gets upset if this is set every frame
 			if (device->getCursorControl()->isVisible())
 				device->getCursorControl()->setVisible(false);
 		}
-#endif

 		if (flags->first_loop_after_window_activation)
 			flags->first_loop_after_window_activation = false;
@ -3063,11 +3016,9 @@ void Game::updateCameraDirection(CameraOrientation *cam,
 				(driver->getScreenSize().Height / 2));
 	} else {

-#ifndef ANDROID
 		// Mac OSX gets upset if this is set every frame
 		if (device->getCursorControl()->isVisible() == false)
 			device->getCursorControl()->setVisible(true);
-#endif

 		if (!flags->first_loop_after_window_activation)
 			flags->first_loop_after_window_activation = true;
@ -3134,18 +3085,6 @@ void Game::updatePlayerControl(const CameraOrientation &cam)
 			( (u32)(input->getRightState()                                       & 0x1) << 8
 		);

-#ifdef ANDROID
-	/* For Android, simulate holding down AUX1 (fast move) if the user has
-	 * the fast_move setting toggled on. If there is an aux1 key defined for
-	 * Android then its meaning is inverted (i.e. holding aux1 means walk and
-	 * not fast)
-	 */
-	if (m_cache_hold_aux1) {
-		control.aux1 = control.aux1 ^ true;
-		keypress_bits ^= ((u32)(1U << 5));
-	}
-#endif
-
 	client->setPlayerControl(control);
 	LocalPlayer *player = client->getEnv().getLocalPlayer();
 	player->keyPressed = keypress_bits;
--- a/src/guiEngine.cpp
+++ b/src/guiEngine.cpp
@ -41,11 +41,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "fontengine.h"
 #include "guiscalingfilter.h"

-#ifdef __ANDROID__
-#include "client/tile.h"
-#include <GLES/gl.h>
-#endif
-

 /******************************************************************************/
 /** TextDestGuiEngine                                                         */
@ -95,15 +90,6 @@ video::ITexture* MenuTextureSource::getTexture(const std::string &name, u32 *id)
 		return NULL;
 	m_to_delete.insert(name);

-#ifdef __ANDROID__
-	video::IImage *image = m_driver->createImageFromFile(name.c_str());
-	if (image) {
-		image = Align2Npot2(image, m_driver);
-		video::ITexture* retval = m_driver->addTexture(name.c_str(), image);
-		image->drop();
-		return retval;
-	}
-#endif
 	return m_driver->getTexture(name.c_str());
 }

@ -296,9 +282,6 @@ void GUIEngine::run()

 		m_script->step();

-#ifdef __ANDROID__
-		m_menu->getAndroidUIInput();
-#endif
 	}
 }

--- a/src/guiFormSpecMenu.cpp
+++ b/src/guiFormSpecMenu.cpp
@ -106,9 +106,6 @@ GUIFormSpecMenu::GUIFormSpecMenu(irr::IrrlichtDevice* dev,
 	m_focused_element(""),
 	m_font(NULL),
 	m_remap_dbl_click(remap_dbl_click)
-#ifdef __ANDROID__
-	, m_JavaDialogFieldName("")
-#endif
 {
 	current_keys_pending.key_down = false;
 	current_keys_pending.key_up = false;
@ -2084,52 +2081,6 @@ void GUIFormSpecMenu::regenerateGui(v2u32 screensize)
 	skin->setFont(old_font);
 }

-#ifdef __ANDROID__
-bool GUIFormSpecMenu::getAndroidUIInput()
-{
-	/* no dialog shown */
-	if (m_JavaDialogFieldName == "") {
-		return false;
-	}
-
-	/* still waiting */
-	if (porting::getInputDialogState() == -1) {
-		return true;
-	}
-
-	std::string fieldname = m_JavaDialogFieldName;
-	m_JavaDialogFieldName = "";
-
-	/* no value abort dialog processing */
-	if (porting::getInputDialogState() != 0) {
-		return false;
-	}
-
-	for(std::vector<FieldSpec>::iterator iter =  m_fields.begin();
-			iter != m_fields.end(); ++iter) {
-
-		if (iter->fname != fieldname) {
-			continue;
-		}
-		IGUIElement* tochange = getElementFromId(iter->fid);
-
-		if (tochange == 0) {
-			return false;
-		}
-
-		if (tochange->getType() != irr::gui::EGUIET_EDIT_BOX) {
-			return false;
-		}
-
-		std::string text = porting::getInputDialogValue();
-
-		((gui::IGUIEditBox*) tochange)->
-			setText(utf8_to_wide(text).c_str());
-	}
-	return false;
-}
-#endif
-
 GUIFormSpecMenu::ItemSpec GUIFormSpecMenu::getItemAtPos(v2s32 p) const
 {
 	core::rect<s32> imgrect(0,0,imgsize.X,imgsize.Y);
@ -2254,12 +2205,6 @@ void GUIFormSpecMenu::drawList(const ListDrawSpec &s, int phase)
 				v2u32 screenSize = driver->getScreenSize();
 				int tooltip_offset_x = m_btn_height;
 				int tooltip_offset_y = m_btn_height;
-#ifdef __ANDROID__
-				tooltip_offset_x *= 3;
-				tooltip_offset_y  = 0;
-				if (m_pointer.X > (s32)screenSize.X / 2)
-					tooltip_offset_x = (tooltip_offset_x + tooltip_width) * -1;
-#endif
 				s32 tooltip_x = m_pointer.X + tooltip_offset_x;
 				s32 tooltip_y = m_pointer.Y + tooltip_offset_y;
 				if (tooltip_x + tooltip_width > (s32)screenSize.X)
@ -2486,12 +2431,6 @@ void GUIFormSpecMenu::drawMenu()
 						s32 tooltip_height = m_tooltip_element->getTextHeight() * tt_rows.size() + 5;
 						int tooltip_offset_x = m_btn_height;
 						int tooltip_offset_y = m_btn_height;
-#ifdef __ANDROID__
-						tooltip_offset_x *= 3;
-						tooltip_offset_y  = 0;
-						if (m_pointer.X > (s32)screenSize.X / 2)
-							tooltip_offset_x = (tooltip_offset_x + tooltip_width) * -1;
-#endif
 						s32 tooltip_x = m_pointer.X + tooltip_offset_x;
 						s32 tooltip_y = m_pointer.Y + tooltip_offset_y;
 						if (tooltip_x + tooltip_width > (s32)screenSize.X)
@ -2844,156 +2783,6 @@ bool GUIFormSpecMenu::preprocessEvent(const SEvent& event)
 		}
 	}

-	#ifdef __ANDROID__
-	// display software keyboard when clicking edit boxes
-	if (event.EventType == EET_MOUSE_INPUT_EVENT
-			&& event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
-		gui::IGUIElement *hovered =
-			Environment->getRootGUIElement()->getElementFromPoint(
-				core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y));
-		if ((hovered) && (hovered->getType() == irr::gui::EGUIET_EDIT_BOX)) {
-			bool retval = hovered->OnEvent(event);
-			if (retval) {
-				Environment->setFocus(hovered);
-			}
-			m_JavaDialogFieldName = getNameByID(hovered->getID());
-			std::string message   = gettext("Enter ");
-			std::string label     = wide_to_utf8(getLabelByID(hovered->getID()));
-			if (label == "") {
-				label = "text";
-			}
-			message += gettext(label) + ":";
-
-			/* single line text input */
-			int type = 2;
-
-			/* multi line text input */
-			if (((gui::IGUIEditBox*) hovered)->isMultiLineEnabled()) {
-				type = 1;
-			}
-
-			/* passwords are always single line */
-			if (((gui::IGUIEditBox*) hovered)->isPasswordBox()) {
-				type = 3;
-			}
-
-			porting::showInputDialog(gettext("ok"), "",
-					wide_to_utf8(((gui::IGUIEditBox*) hovered)->getText()),
-					type);
-			return retval;
-		}
-	}
-
-	if (event.EventType == EET_TOUCH_INPUT_EVENT)
-	{
-		SEvent translated;
-		memset(&translated, 0, sizeof(SEvent));
-		translated.EventType   = EET_MOUSE_INPUT_EVENT;
-		gui::IGUIElement* root = Environment->getRootGUIElement();
-
-		if (!root) {
-			errorstream
-			<< "GUIFormSpecMenu::preprocessEvent unable to get root element"
-			<< std::endl;
-			return false;
-		}
-		gui::IGUIElement* hovered = root->getElementFromPoint(
-			core::position2d<s32>(
-					event.TouchInput.X,
-					event.TouchInput.Y));
-
-		translated.MouseInput.X = event.TouchInput.X;
-		translated.MouseInput.Y = event.TouchInput.Y;
-		translated.MouseInput.Control = false;
-
-		bool dont_send_event = false;
-
-		if (event.TouchInput.touchedCount == 1) {
-			switch (event.TouchInput.Event) {
-				case ETIE_PRESSED_DOWN:
-					m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y);
-					translated.MouseInput.Event = EMIE_LMOUSE_PRESSED_DOWN;
-					translated.MouseInput.ButtonStates = EMBSM_LEFT;
-					m_down_pos = m_pointer;
-					break;
-				case ETIE_MOVED:
-					m_pointer = v2s32(event.TouchInput.X,event.TouchInput.Y);
-					translated.MouseInput.Event = EMIE_MOUSE_MOVED;
-					translated.MouseInput.ButtonStates = EMBSM_LEFT;
-					break;
-				case ETIE_LEFT_UP:
-					translated.MouseInput.Event = EMIE_LMOUSE_LEFT_UP;
-					translated.MouseInput.ButtonStates = 0;
-					hovered = root->getElementFromPoint(m_down_pos);
-					/* we don't have a valid pointer element use last
-					 * known pointer pos */
-					translated.MouseInput.X = m_pointer.X;
-					translated.MouseInput.Y = m_pointer.Y;
-
-					/* reset down pos */
-					m_down_pos = v2s32(0,0);
-					break;
-				default:
-					dont_send_event = true;
-					//this is not supposed to happen
-					errorstream
-					<< "GUIFormSpecMenu::preprocessEvent unexpected usecase Event="
-					<< event.TouchInput.Event << std::endl;
-			}
-		} else if ( (event.TouchInput.touchedCount == 2) &&
-				(event.TouchInput.Event == ETIE_PRESSED_DOWN) ) {
-			hovered = root->getElementFromPoint(m_down_pos);
-
-			translated.MouseInput.Event = EMIE_RMOUSE_PRESSED_DOWN;
-			translated.MouseInput.ButtonStates = EMBSM_LEFT | EMBSM_RIGHT;
-			translated.MouseInput.X = m_pointer.X;
-			translated.MouseInput.Y = m_pointer.Y;
-
-			if (hovered) {
-				hovered->OnEvent(translated);
-			}
-
-			translated.MouseInput.Event = EMIE_RMOUSE_LEFT_UP;
-			translated.MouseInput.ButtonStates = EMBSM_LEFT;
-
-
-			if (hovered) {
-				hovered->OnEvent(translated);
-			}
-			dont_send_event = true;
-		}
-		/* ignore unhandled 2 touch events ... accidental moving for example */
-		else if (event.TouchInput.touchedCount == 2) {
-			dont_send_event = true;
-		}
-		else if (event.TouchInput.touchedCount > 2) {
-			errorstream
-			<< "GUIFormSpecMenu::preprocessEvent to many multitouch events "
-			<< event.TouchInput.touchedCount << " ignoring them" << std::endl;
-		}
-
-		if (dont_send_event) {
-			return true;
-		}
-
-		/* check if translated event needs to be preprocessed again */
-		if (preprocessEvent(translated)) {
-			return true;
-		}
-		if (hovered) {
-			grab();
-			bool retval = hovered->OnEvent(translated);
-
-			if (event.TouchInput.Event == ETIE_LEFT_UP) {
-				/* reset pointer */
-				m_pointer = v2s32(0,0);
-			}
-			drop();
-			return retval;
-		}
-	}
-	#endif
-
 	return false;
 }

--- a/src/guiFormSpecMenu.h
+++ b/src/guiFormSpecMenu.h
@ -299,10 +299,6 @@ public:

 	GUITable* getTable(const std::string &tablename);

-#ifdef __ANDROID__
-	bool getAndroidUIInput();
-#endif
-
 protected:
 	v2s32 getBasePos() const
 	{
@ -452,14 +448,9 @@ private:

 	std::wstring getLabelByID(s32 id);
 	std::string getNameByID(s32 id);
-#ifdef __ANDROID__
-	v2s32 m_down_pos;
-	std::string m_JavaDialogFieldName;
-#endif

-	/* If true, remap a double-click (or double-tap) action to ESC. This is so
-	 * that, for example, Android users can double-tap to close a formspec.
-	*
+
+	/* If true, remap a double-click (or double-tap) action to ESC.
 	 * This value can (currently) only be set by the class constructor
 	 * and the default value for the setting is true.
 	 */
--- a/src/guiscalingfilter.cpp
+++ b/src/guiscalingfilter.cpp
@ -117,19 +117,6 @@ video::ITexture *guiScalingResizeCached(video::IVideoDriver *driver,
 			(u32)destrect.getHeight()));
 	imageScaleNNAA(srcimg, srcrect, destimg);

-#ifdef __ANDROID__
-	// Android is very picky about textures being powers of 2, so expand
-	// the image dimensions to the next power of 2, if necessary, for
-	// that platform.
-	video::IImage *po2img = driver->createImage(src->getColorFormat(),
-			core::dimension2d<u32>(npot2((u32)destrect.getWidth()),
-			npot2((u32)destrect.getHeight())));
-	po2img->fill(video::SColor(0, 0, 0, 0));
-	destimg->copyTo(po2img);
-	destimg->drop();
-	destimg = po2img;
-#endif
-
 	// Convert the scaled image back into a texture.
 	scaled = driver->addTexture(scalename, destimg, NULL);
 	destimg->drop();
--- a/src/itemdef.cpp
+++ b/src/itemdef.cpp
@ -41,9 +41,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <map>
 #include <set>

-#ifdef __ANDROID__
-#include <GLES/gl.h>
-#endif

 /*
 	ItemDefinition
@ -414,11 +411,6 @@ public:
 				params.light_color.set(1.0, 0.5, 0.5, 0.5);
 				params.light_radius = 1000;

-#ifdef __ANDROID__
-				params.camera_position.set(0, -1.0, -1.5);
-				params.camera_position.rotateXZBy(45);
-				params.light_position.set(10, -100, -50);
-#endif
 				cc->inventory_texture =
 					tsrc->generateTextureFromMesh(params);

--- a/src/localplayer.cpp
+++ b/src/localplayer.cpp
@ -210,10 +210,6 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
 	// this shouldn't be hardcoded but transmitted from server
 	float player_stepheight = touching_ground ? (BS*0.6) : (BS*0.2);

-#ifdef __ANDROID__
-	player_stepheight += (0.5 * BS);
-#endif
-
 	v3f accel_f = v3f(0,0,0);

 	collisionMoveResult result = collisionMoveSimple(env, m_gamedef,
--- a/src/log.cpp
+++ b/src/log.cpp
@ -112,43 +112,6 @@ std::ostream actionstream(&action_buf);
 std::ostream infostream(&info_buf);
 std::ostream verbosestream(&verbose_buf);

-// Android
-#ifdef __ANDROID__
-
-static unsigned int g_level_to_android[] = {
-	ANDROID_LOG_INFO,     // LL_NONE
-	//ANDROID_LOG_FATAL,
-	ANDROID_LOG_ERROR,    // LL_ERROR
-	ANDROID_LOG_WARN,     // LL_WARNING
-	ANDROID_LOG_WARN,     // LL_ACTION
-	//ANDROID_LOG_INFO,
-	ANDROID_LOG_DEBUG,    // LL_INFO
-	ANDROID_LOG_VERBOSE,  // LL_VERBOSE
-};
-
-class AndroidSystemLogOutput : public ICombinedLogOutput {
-	public:
-		AndroidSystemLogOutput()
-		{
-			g_logger.addOutput(this);
-		}
-		~AndroidSystemLogOutput()
-		{
-			g_logger.removeOutput(this);
-		}
-		void logRaw(LogLevel lev, const std::string &line)
-		{
-			STATIC_ASSERT(ARRLEN(g_level_to_android) == LL_MAX,
-				mismatch_between_android_and_internal_loglevels);
-			__android_log_print(g_level_to_android[lev],
-				PROJECT_NAME_C, "%s", line.c_str());
-		}
-};
-
-AndroidSystemLogOutput g_android_log_output;
-
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////


--- a/src/lua/src/llex.c
+++ b/src/lua/src/llex.c
@ -176,15 +176,9 @@ static void buffreplace (LexState *ls, char from, char to) {

 static void trydecpoint (LexState *ls, SemInfo *seminfo) {
  /* format error: try to update decimal point separator */
-#ifndef __ANDROID__
  struct lconv *cv = localeconv();
-#endif
  char old = ls->decpoint;
-#ifndef __ANDROID__
  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
-#else
-  ls->decpoint = '.';
-#endif
  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
    /* format error with correct decimal point: no more options */
@ -464,4 +458,3 @@ void luaX_lookahead (LexState *ls) {
  lua_assert(ls->lookahead.token == TK_EOS);
  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
 }
-
--- a/src/main.cpp
+++ b/src/main.cpp
@ -195,12 +195,10 @@ int main(int argc, char *argv[])
 	if (!init_common(cmd_args, argc, argv))
 		return 1;

-#ifndef __ANDROID__
 	// Run unit tests
 	if (cmd_args.getFlag("run-unittests")) {
 		return run_tests();
 	}
-#endif

 	GameParams game_params;
 #ifdef SERVER
@ -424,20 +422,8 @@ static bool create_userdata_path()
 {
 	bool success;

-#ifdef __ANDROID__
-	porting::initAndroid();
-
-	porting::setExternalStorageDir(porting::jnienv);
-	if (!fs::PathExists(porting::path_user)) {
-		success = fs::CreateDir(porting::path_user);
-	} else {
-		success = true;
-	}
-	porting::copyAssets();
-#else
 	// Create user data directory
 	success = fs::CreateDir(porting::path_user);
-#endif

 	infostream << "path_share = " << porting::path_share << std::endl;
 	infostream << "path_user  = " << porting::path_user << std::endl;
--- a/src/mainmenumanager.h
+++ b/src/mainmenumanager.h
@ -140,9 +140,6 @@ public:
 	virtual void exitToOS()
 	{
 		shutdown_requested = true;
-#ifndef __ANDROID__
-		device->closeDevice();
-#endif
 	}

 	virtual void disconnect()
--- a/src/porting.cpp
+++ b/src/porting.cpp
@ -44,8 +44,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 	#define _PSTAT64
 	#include <sys/pstat.h>
 #endif
-#if !defined(_WIN32) && !defined(__APPLE__) && \
-	!defined(__ANDROID__) && !defined(SERVER)
+#if !defined(_WIN32) && !defined(__APPLE__) && !defined(SERVER)
 	#define XORG_USED
 #endif
 #ifdef XORG_USED
@ -375,11 +374,7 @@ bool setSystemPaths()
 	char buf[BUFSIZ];

 	if (!getCurrentExecPath(buf, sizeof(buf))) {
-#ifdef __ANDROID__
-		errorstream << "Unable to read bindir "<< std::endl;
-#else
 		FATAL_ERROR("Unable to read bindir");
-#endif
 		return false;
 	}

@ -397,10 +392,6 @@ bool setSystemPaths()
 		DIR_DELIM + PROJECT_NAME);
 	trylist.push_back(bindir + DIR_DELIM "..");

-#ifdef __ANDROID__
-	trylist.push_back(path_user);
-#endif
-
 	for (std::list<std::string>::const_iterator
 			i = trylist.begin(); i != trylist.end(); i++) {
 		const std::string &trypath = *i;
@ -421,10 +412,7 @@ bool setSystemPaths()
 		break;
 	}

-#ifndef __ANDROID__
-	path_user = std::string(getenv("HOME")) + DIR_DELIM "."
-		+ PROJECT_NAME;
-#endif
+	path_user = std::string(getenv("HOME")) + DIR_DELIM "." + PROJECT_NAME;

 	return true;
 }
@ -652,7 +640,6 @@ const char *getVideoDriverFriendlyName(irr::video::E_DRIVER_TYPE type)
 	return driver_names[type];
 }

-#	ifndef __ANDROID__
 #ifdef XORG_USED

 static float calcDisplayDensity()
@ -687,12 +674,12 @@ float getDisplayDensity()
 }


-#		else // XORG_USED
+#else
 float getDisplayDensity()
 {
 	return g_settings->getFloat("screen_dpi")/96.0;
 }
-#		endif // XORG_USED
+#endif

 v2u32 getDisplaySize()
 {
@ -703,7 +690,6 @@ v2u32 getDisplaySize()

 	return deskres;
 }
-#	endif // __ANDROID__
 #endif // SERVER


--- a/src/porting.h
+++ b/src/porting.h
@ -298,9 +298,7 @@ const char *getVideoDriverFriendlyName(irr::video::E_DRIVER_TYPE type);
 inline const char *getPlatformName()
 {
 	return
-#if defined(ANDROID)
-	"Android"
-#elif defined(linux) || defined(__linux) || defined(__linux__)
+#if defined(linux) || defined(__linux) || defined(__linux__)
 	"Linux"
 #elif defined(_WIN32) || defined(_WIN64)
 	"Windows"
@ -349,8 +347,4 @@ void setWin32ExceptionHandler();
 bool secure_rand_fill_buf(void *buf, size_t len);
 } // namespace porting

-#ifdef __ANDROID__
-#include "porting_android.h"
-#endif
-
 #endif // PORTING_HEADER
--- a/src/porting_android.cpp
+++ b/src/porting_android.cpp
@ -1,296 +0,0 @@
-/*
-BlockPlanet
-Copyright (C) BlockMen 2015 <blockmen2015@gmail.com>
-
-This file is part of BlockPlanet.
-Minetest
-Copyright (C) 2014 celeron55, Perttu Ahola <celeron55@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __ANDROID__
-#error This file may only be compiled for android!
-#endif
-
-#include "util/numeric.h"
-#include "porting.h"
-#include "porting_android.h"
-#include "threading/thread.h"
-#include "config.h"
-#include "filesys.h"
-#include "log.h"
-
-#include <sstream>
-#include <exception>
-#include <stdlib.h>
-
-#ifdef GPROF
-#include "prof.h"
-#endif
-
-extern int main(int argc, char *argv[]);
-
-void android_main(android_app *app)
-{
-	int retval = 0;
-	porting::app_global = app;
-
-	Thread::setName("Main");
-
-	try {
-		app_dummy();
-		char *argv[] = {strdup(PROJECT_NAME), NULL};
-		main(ARRLEN(argv) - 1, argv);
-		free(argv[0]);
-	} catch (std::exception &e) {
-		errorstream << "Uncaught exception in main thread: " << e.what() << std::endl;
-		retval = -1;
-	} catch (...) {
-		errorstream << "Uncaught exception in main thread!" << std::endl;
-		retval = -1;
-	}
-
-	porting::cleanupAndroid();
-	infostream << "Shutting down." << std::endl;
-	exit(retval);
-}
-
-/* handler for finished message box input */
-/* Intentionally NOT in namespace porting */
-/* TODO this doesn't work as expected, no idea why but there's a workaround   */
-/* for it right now */
-extern "C" {
-	JNIEXPORT void JNICALL Java_net_minetest_MtNativeActivity_putMessageBoxResult(
-			JNIEnv * env, jclass thiz, jstring text)
-	{
-		errorstream << "Java_net_minetest_MtNativeActivity_putMessageBoxResult got: "
-				<< std::string((const char*)env->GetStringChars(text,0))
-				<< std::endl;
-	}
-}
-
-namespace porting {
-
-std::string path_storage = DIR_DELIM "sdcard" DIR_DELIM;
-
-android_app* app_global;
-JNIEnv*      jnienv;
-jclass       nativeActivity;
-
-jclass findClass(std::string classname)
-{
-	if (jnienv == 0) {
-		return 0;
-	}
-
-	jclass nativeactivity = jnienv->FindClass("android/app/NativeActivity");
-	jmethodID getClassLoader =
-			jnienv->GetMethodID(nativeactivity,"getClassLoader",
-					"()Ljava/lang/ClassLoader;");
-	jobject cls =
-			jnienv->CallObjectMethod(app_global->activity->clazz, getClassLoader);
-	jclass classLoader = jnienv->FindClass("java/lang/ClassLoader");
-	jmethodID findClass =
-			jnienv->GetMethodID(classLoader, "loadClass",
-					"(Ljava/lang/String;)Ljava/lang/Class;");
-	jstring strClassName =
-			jnienv->NewStringUTF(classname.c_str());
-	return (jclass) jnienv->CallObjectMethod(cls, findClass, strClassName);
-}
-
-void copyAssets()
-{
-	jmethodID assetcopy = jnienv->GetMethodID(nativeActivity,"copyAssets","()V");
-
-	if (assetcopy == 0) {
-		assert("porting::copyAssets unable to find copy assets method" == 0);
-	}
-
-	jnienv->CallVoidMethod(app_global->activity->clazz, assetcopy);
-}
-
-void initAndroid()
-{
-	porting::jnienv = NULL;
-	JavaVM *jvm = app_global->activity->vm;
-	JavaVMAttachArgs lJavaVMAttachArgs;
-	lJavaVMAttachArgs.version = JNI_VERSION_1_6;
-	lJavaVMAttachArgs.name = PROJECT_NAME_C "NativeThread";
-	lJavaVMAttachArgs.group = NULL;
-#ifdef NDEBUG
-	// This is a ugly hack as arm v7a non debuggable builds crash without this
-	// printf ... if someone finds out why please fix it!
-	infostream << "Attaching native thread. " << std::endl;
-#endif
-	if ( jvm->AttachCurrentThread(&porting::jnienv, &lJavaVMAttachArgs) == JNI_ERR) {
-		errorstream << "Failed to attach native thread to jvm" << std::endl;
-		exit(-1);
-	}
-
-	nativeActivity = findClass("net/minetest/minetest/MtNativeActivity");
-	if (nativeActivity == 0) {
-		errorstream <<
-			"porting::initAndroid unable to find java native activity class" <<
-			std::endl;
-	}
-
-#ifdef GPROF
-	/* in the start-up code */
-	__android_log_print(ANDROID_LOG_ERROR, PROJECT_NAME_C,
-			"Initializing GPROF profiler");
-	monstartup("libminetest.so");
-#endif
-}
-
-void cleanupAndroid()
-{
-
-#ifdef GPROF
-	errorstream << "Shutting down GPROF profiler" << std::endl;
-	setenv("CPUPROFILE", (path_user + DIR_DELIM + "gmon.out").c_str(), 1);
-	moncleanup();
-#endif
-
-	JavaVM *jvm = app_global->activity->vm;
-	jvm->DetachCurrentThread();
-}
-
-void setExternalStorageDir(JNIEnv* lJNIEnv)
-{
-	// Android: Retrieve ablsolute path to external storage device (sdcard)
-	jclass ClassEnv      = lJNIEnv->FindClass("android/os/Environment");
-	jmethodID MethodDir  =
-			lJNIEnv->GetStaticMethodID(ClassEnv,
-					"getExternalStorageDirectory","()Ljava/io/File;");
-	jobject ObjectFile   = lJNIEnv->CallStaticObjectMethod(ClassEnv, MethodDir);
-	jclass ClassFile     = lJNIEnv->FindClass("java/io/File");
-
-	jmethodID MethodPath =
-			lJNIEnv->GetMethodID(ClassFile, "getAbsolutePath",
-					"()Ljava/lang/String;");
-	jstring StringPath   =
-			(jstring) lJNIEnv->CallObjectMethod(ObjectFile, MethodPath);
-
-	const char *externalPath = lJNIEnv->GetStringUTFChars(StringPath, NULL);
-	std::string userPath(externalPath);
-	lJNIEnv->ReleaseStringUTFChars(StringPath, externalPath);
-
-	path_storage             = userPath;
-	path_user                = userPath + DIR_DELIM + PROJECT_NAME_C;
-	path_share               = userPath + DIR_DELIM + PROJECT_NAME_C;
-}
-
-void showInputDialog(const std::string& acceptButton, const  std::string& hint,
-		const std::string& current, int editType)
-{
-	jmethodID showdialog = jnienv->GetMethodID(nativeActivity,"showDialog",
-		"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V");
-
-	if (showdialog == 0) {
-		assert("porting::showInputDialog unable to find java show dialog method" == 0);
-	}
-
-	jstring jacceptButton = jnienv->NewStringUTF(acceptButton.c_str());
-	jstring jhint         = jnienv->NewStringUTF(hint.c_str());
-	jstring jcurrent      = jnienv->NewStringUTF(current.c_str());
-	jint    jeditType     = editType;
-
-	jnienv->CallVoidMethod(app_global->activity->clazz, showdialog,
-			jacceptButton, jhint, jcurrent, jeditType);
-}
-
-int getInputDialogState()
-{
-	jmethodID dialogstate = jnienv->GetMethodID(nativeActivity,
-			"getDialogState", "()I");
-
-	if (dialogstate == 0) {
-		assert("porting::getInputDialogState unable to find java dialog state method" == 0);
-	}
-
-	return jnienv->CallIntMethod(app_global->activity->clazz, dialogstate);
-}
-
-std::string getInputDialogValue()
-{
-	jmethodID dialogvalue = jnienv->GetMethodID(nativeActivity,
-			"getDialogValue", "()Ljava/lang/String;");
-
-	if (dialogvalue == 0) {
-		assert("porting::getInputDialogValue unable to find java dialog value method" == 0);
-	}
-
-	jobject result = jnienv->CallObjectMethod(app_global->activity->clazz,
-			dialogvalue);
-
-	const char* javachars = jnienv->GetStringUTFChars((jstring) result,0);
-	std::string text(javachars);
-	jnienv->ReleaseStringUTFChars((jstring) result, javachars);
-
-	return text;
-}
-
-#ifndef SERVER
-float getDisplayDensity()
-{
-	static bool firstrun = true;
-	static float value = 0;
-
-	if (firstrun) {
-		jmethodID getDensity = jnienv->GetMethodID(nativeActivity, "getDensity",
-					"()F");
-
-		if (getDensity == 0) {
-			assert("porting::getDisplayDensity unable to find java getDensity method" == 0);
-		}
-
-		value = jnienv->CallFloatMethod(app_global->activity->clazz, getDensity);
-		firstrun = false;
-	}
-	return value;
-}
-
-v2u32 getDisplaySize()
-{
-	static bool firstrun = true;
-	static v2u32 retval;
-
-	if (firstrun) {
-		jmethodID getDisplayWidth = jnienv->GetMethodID(nativeActivity,
-				"getDisplayWidth", "()I");
-
-		if (getDisplayWidth == 0) {
-			assert("porting::getDisplayWidth unable to find java getDisplayWidth method" == 0);
-		}
-
-		retval.X = jnienv->CallIntMethod(app_global->activity->clazz,
-				getDisplayWidth);
-
-		jmethodID getDisplayHeight = jnienv->GetMethodID(nativeActivity,
-				"getDisplayHeight", "()I");
-
-		if (getDisplayHeight == 0) {
-			assert("porting::getDisplayHeight unable to find java getDisplayHeight method" == 0);
-		}
-
-		retval.Y = jnienv->CallIntMethod(app_global->activity->clazz,
-				getDisplayHeight);
-
-		firstrun = false;
-	}
-	return retval;
-}
-#endif // ndef SERVER
-}
--- a/src/porting_android.h
+++ b/src/porting_android.h
@ -1,84 +0,0 @@
-/*
-BlockPlanet
-
-
-This file is part of BlockPlanet.
-Minetest
-Copyright (C) 2014 celeron55, Perttu Ahola <celeron55@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __PORTING_ANDROID_H__
-#define __PORTING_ANDROID_H__
-
-#ifndef __ANDROID__
-#error this include has to be included on android port only!
-#endif
-
-#include <jni.h>
-#include <android_native_app_glue.h>
-#include <android/log.h>
-
-#include <string>
-
-namespace porting {
-/** java app **/
-extern android_app *app_global;
-
-/** java <-> c++ interaction interface **/
-extern JNIEnv *jnienv;
-
-/**
- * do initialization required on android only
- */
-void initAndroid();
-void cleanupAndroid();
-
-/**
- * set storage dir on external sdcard#
- * @param lJNIEnv environment from android
- */
-void setExternalStorageDir(JNIEnv* lJNIEnv);
-
-/**
- * use java function to copy media from assets to external storage
- */
-void copyAssets();
-
-/**
- * show text input dialog in java
- * @param acceptButton text to display on accept button
- * @param hint hint to show
- * @param current initial value to display
- * @param editType type of texfield
- * (1==multiline text input; 2==single line text input; 3=password field)
- */
-void showInputDialog(const std::string& acceptButton,
-		const  std::string& hint, const std::string& current, int editType);
-
-/**
- * WORKAROUND for not working callbacks from java -> c++
- * get current state of input dialog
- */
-int getInputDialogState();
-
-/**
- * WORKAROUND for not working callbacks from java -> c++
- * get text in current input dialog
- */
-std::string getInputDialogValue();
-
-}
-
-#endif
--- a/src/script/lua_api/l_areastore.cpp
+++ b/src/script/lua_api/l_areastore.cpp
@ -27,9 +27,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "cpp_api/s_security.h"
 #include "areastore.h"
 #include "filesys.h"
-#ifndef ANDROID
 #include "cmake_config.h"
-#endif
 #include <fstream>

 static inline void get_data_and_border_flags(lua_State *L, u8 start_i,
--- a/src/threading/semaphore.cpp
+++ b/src/threading/semaphore.cpp
@ -74,12 +74,7 @@ Semaphore::~Semaphore()
 	CloseHandle(semaphore);
 #else
 	int ret = sem_destroy(&semaphore);
-#ifdef __ANDROID__
-	// Workaround for broken bionic semaphore implementation!
-	assert(!ret || errno == EBUSY);
-#else
 	assert(!ret);
-#endif
 	UNUSED(ret);
 #endif
 }
--- a/src/threading/thread.cpp
+++ b/src/threading/thread.cpp
@ -205,14 +205,8 @@ bool Thread::kill()
 #ifdef _WIN32
 	TerminateThread(m_thread_handle, 0);
 	CloseHandle(m_thread_handle);
-#else
-	// We need to pthread_kill instead on Android since NDKv5's pthread
-	// implementation is incomplete.
-# ifdef __ANDROID__
-	pthread_kill(m_thread_handle, SIGKILL);
 #else
 	pthread_cancel(m_thread_handle);
-# endif
 	wait();
 #endif

@ -365,11 +359,8 @@ unsigned int Thread::getNumberOfProcessors()

 bool Thread::bindToProcessor(unsigned int proc_number)
 {
-#if defined(__ANDROID__)

-	return false;
-
-#elif defined(_WIN32)
+#if defined(_WIN32)

 	return SetThreadAffinityMask(m_thread_handle, 1 << proc_number);

@ -437,4 +428,3 @@ bool Thread::setPriority(int prio)

 #endif
 }
-
--- a/src/util/srp.cpp
+++ b/src/util/srp.cpp
@ -39,7 +39,7 @@

 #include <config.h>

-#if USE_SYSTEM_GMP || defined (__ANDROID__) || defined (ANDROID)
+#if USE_SYSTEM_GMP
 	#include <gmp.h>
 #else
 	#include <gmp/mini-gmp.h>
--- a/src/util/string.cpp
+++ b/src/util/string.cpp
@ -105,13 +105,6 @@ std::wstring utf8_to_wide(const std::string &input)
 	return out;
 }

-#ifdef __ANDROID__
-// TODO: this is an ugly fix for wide_to_utf8 somehow not working on android
-std::string wide_to_utf8(const std::wstring &input)
-{
-	return wide_to_narrow(input);
-}
-#else
 std::string wide_to_utf8(const std::wstring &input)
 {
 	size_t inbuf_size = (input.length() + 1) * sizeof(wchar_t);
@ -138,7 +131,6 @@ std::string wide_to_utf8(const std::wstring &input)
 	return out;
 }

-#endif
 #else // _WIN32

 std::wstring utf8_to_wide(const std::string &input)
@ -202,64 +194,6 @@ wchar_t *narrow_to_wide_c(const char *str)
 	return nstr;
 }

-
-#ifdef __ANDROID__
-
-const wchar_t* wide_chars =
-	L" !\"#$%&'()*+,-./0123456789:;<=>?@"
-	L"ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`"
-	L"abcdefghijklmnopqrstuvwxyz{|}~";
-
-int wctomb(char *s, wchar_t wc)
-{
-	for (unsigned int j = 0; j < (sizeof(wide_chars)/sizeof(wchar_t));j++) {
-		if (wc == wide_chars[j]) {
-			*s = (char) (j+32);
-			return 1;
-		}
-		else if (wc == L'\n') {
-			*s = '\n';
-			return 1;
-		}
-	}
-	return -1;
-}
-
-int mbtowc(wchar_t *pwc, const char *s, size_t n)
-{
-	std::wstring intermediate = narrow_to_wide(s);
-
-	if (intermediate.length() > 0) {
-		*pwc = intermediate[0];
-		return 1;
-	}
-	else {
-		return -1;
-	}
-}
-
-std::wstring narrow_to_wide(const std::string &mbs) {
-	size_t wcl = mbs.size();
-
-	std::wstring retval = L"";
-
-	for (unsigned int i = 0; i < wcl; i++) {
-		if (((unsigned char) mbs[i] >31) &&
-		 ((unsigned char) mbs[i] < 127)) {
-
-			retval += wide_chars[(unsigned char) mbs[i] -32];
-		}
-		//handle newline
-		else if (mbs[i] == '\n') {
-			retval += L'\n';
-		}
-	}
-
-	return retval;
-}
-
-#else // not Android
-
 std::wstring narrow_to_wide(const std::string &mbs)
 {
 	size_t wcl = mbs.size();
@ -271,38 +205,6 @@ std::wstring narrow_to_wide(const std::string &mbs)
 	return *wcs;
 }

-#endif
-
-#ifdef __ANDROID__
-
-std::string wide_to_narrow(const std::wstring &wcs) {
-	size_t mbl = wcs.size()*4;
-
-	std::string retval = "";
-	for (unsigned int i = 0; i < wcs.size(); i++) {
-		wchar_t char1 = (wchar_t) wcs[i];
-
-		if (char1 == L'\n') {
-			retval += '\n';
-			continue;
-		}
-
-		for (unsigned int j = 0; j < wcslen(wide_chars);j++) {
-			wchar_t char2 = (wchar_t) wide_chars[j];
-
-			if (char1 == char2) {
-				char toadd = (j+32);
-				retval += toadd;
-				break;
-			}
-		}
-	}
-
-	return retval;
-}
-
-#else // not Android
-
 std::string wide_to_narrow(const std::wstring &wcs)
 {
 	size_t mbl = wcs.size() * 4;
@ -315,8 +217,6 @@ std::string wide_to_narrow(const std::wstring &wcs)
 	return *mbs;
 }

-#endif
-
 std::string urlencode(std::string str)
 {
 	// Encodes non-unreserved URI characters by a percent sign
--- a/src/version.cpp
+++ b/src/version.cpp
@ -23,10 +23,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "version.h"
 #include "config.h"

-#if defined(__ANDROID__)
-	#include "android_version.h"
-	#include "android_version_githash.h"
-#elif defined(USE_CMAKE_CONFIG_H)
+#if defined(USE_CMAKE_CONFIG_H)
 	#include "cmake_config_githash.h"
 #endif

--- a/util/bump_version.sh
+++ b/util/bump_version.sh
@ -32,15 +32,12 @@ cd ${0%/*}/..
 grep -q -E '^set\(VERSION_MAJOR [0-9]+\)$' CMakeLists.txt || die "error: Could not find CMakeLists.txt"
 grep -q -E '^set\(VERSION_MINOR [0-9]+\)$' CMakeLists.txt || die "error: Could not find CMakeLists.txt"
 grep -q -E '^set\(VERSION_PATCH [0-9]+\)$' CMakeLists.txt || die "error: Could not find CMakeLists.txt"
-grep -q -E '^ANDROID_VERSION_CODE = [0-9]+$' build/android/Makefile || die "error: Could not find build/android/Makefile"

 VERSION_MAJOR=$(grep -E '^set\(VERSION_MAJOR [0-9]+\)$' CMakeLists.txt | tr -dC 0-9)
 VERSION_MINOR=$(grep -E '^set\(VERSION_MINOR [0-9]+\)$' CMakeLists.txt | tr -dC 0-9)
 VERSION_PATCH=$(grep -E '^set\(VERSION_PATCH [0-9]+\)$' CMakeLists.txt | tr -dC 0-9)
-ANDROID_VERSION_CODE=$(grep -E '^ANDROID_VERSION_CODE = [0-9]+$' build/android/Makefile | tr -dC 0-9)

-echo "Current Minetest version: $VERSION_MAJOR.$VERSION_MINOR.$VERSION_PATCH"
-echo "Current Android version code: $ANDROID_VERSION_CODE"
+echo "Current BlockPlanet version: $VERSION_MAJOR.$VERSION_MINOR.$VERSION_PATCH"


 ########################
@ -66,15 +63,12 @@ fi

 NEW_VERSION_PATCH=$(prompt_for_number "Set patch" $NEW_VERSION_PATCH)

-NEW_ANDROID_VERSION_CODE=$(expr $ANDROID_VERSION_CODE + 1)
-NEW_ANDROID_VERSION_CODE=$(prompt_for_number "Set android version code" $NEW_ANDROID_VERSION_CODE)

 NEW_VERSION="$NEW_VERSION_MAJOR.$NEW_VERSION_MINOR.$NEW_VERSION_PATCH"


 echo
 echo "New version: $NEW_VERSION"
-echo "New android version code: $NEW_ANDROID_VERSION_CODE"


 #######################################
@ -89,14 +83,10 @@ sed -i -re "s/^set\(VERSION_PATCH [0-9]+\)$/set(VERSION_PATCH $NEW_VERSION_PATCH

 sed -i -re "s/^set\(DEVELOPMENT_BUILD TRUE\)$/set(DEVELOPMENT_BUILD FALSE)/" CMakeLists.txt || die "Failed to unset DEVELOPMENT_BUILD"

-sed -i -re "s/^ANDROID_VERSION_CODE = [0-9]+$/ANDROID_VERSION_CODE = $NEW_ANDROID_VERSION_CODE/" build/android/Makefile || die "Failed to update ANDROID_VERSION_CODE"
-
 sed -i -re "1s/[0-9]+\.[0-9]+\.[0-9]+/$NEW_VERSION/g" doc/lua_api.txt || die "Failed to update doc/lua_api.txt"

 sed -i -re "1s/[0-9]+\.[0-9]+\.[0-9]+/$NEW_VERSION/g" doc/menu_lua_api.txt || die "Failed to update doc/menu_lua_api.txt"

-git add -f CMakeLists.txt build/android/Makefile doc/lua_api.txt doc/menu_lua_api.txt || die "git add failed"
-
 git commit -m "Bump version to $NEW_VERSION" || die "git commit failed"

 ############
@ -118,4 +108,3 @@ sed -i -re 's/^set\(DEVELOPMENT_BUILD FALSE\)$/set(DEVELOPMENT_BUILD TRUE)/' CMa
 git add -f CMakeLists.txt || die 'git add failed'

 git commit -m "Continue with $NEW_VERSION-dev" || die 'git commit failed'
-