SCons: Format buildsystem files with psf/black

Configured for a max line length of 120 characters.

psf/black is very opinionated and purposely doesn't leave much room for
configuration. The output is mostly OK so that should be fine for us,
but some things worth noting:

- Manually wrapped strings will be reflowed, so by using a line length
  of 120 for the sake of preserving readability for our long command
  calls, it also means that some manually wrapped strings are back on
  the same line and should be manually merged again.

- Code generators using string concatenation extensively look awful,
  since black puts each operand on a single line. We need to refactor
  these generators to use more pythonic string formatting, for which
  many options are available (`%`, `format` or f-strings).

- CI checks and a pre-commit hook will be added to ensure that future
  buildsystem changes are well-formatted.

2 files changed, 180 insertions, 137 deletions

diff --git a/platform/android/SCsub b/platform/android/SCsub
index 5ca5ce548c..f39eb8b889 100644
--- a/platform/android/SCsub
+++ b/platform/android/SCsub
@@ -1,24 +1,24 @@
 #!/usr/bin/env python
 
-Import('env')
+Import("env")
 
 android_files = [
-    'os_android.cpp',
-    'file_access_android.cpp',
-    'audio_driver_opensl.cpp',
-    'file_access_jandroid.cpp',
-    'dir_access_jandroid.cpp',
-    'thread_jandroid.cpp',
-    'net_socket_android.cpp',
-    'audio_driver_jandroid.cpp',
-    'java_godot_lib_jni.cpp',
-    'java_class_wrapper.cpp',
-    'java_godot_wrapper.cpp',
-    'java_godot_io_wrapper.cpp',
-    'jni_utils.cpp',
-    'android_keys_utils.cpp',
-    'vulkan/vk_renderer_jni.cpp',
-    'plugin/godot_plugin_jni.cpp'
+    "os_android.cpp",
+    "file_access_android.cpp",
+    "audio_driver_opensl.cpp",
+    "file_access_jandroid.cpp",
+    "dir_access_jandroid.cpp",
+    "thread_jandroid.cpp",
+    "net_socket_android.cpp",
+    "audio_driver_jandroid.cpp",
+    "java_godot_lib_jni.cpp",
+    "java_class_wrapper.cpp",
+    "java_godot_wrapper.cpp",
+    "java_godot_io_wrapper.cpp",
+    "jni_utils.cpp",
+    "android_keys_utils.cpp",
+    "vulkan/vk_renderer_jni.cpp",
+    "plugin/godot_plugin_jni.cpp",
 ]
 
 env_android = env.Clone()
@@ -29,30 +29,34 @@ for x in android_files:
 
 env_thirdparty = env_android.Clone()
 env_thirdparty.disable_warnings()
-android_objects.append(env_thirdparty.SharedObject('#thirdparty/misc/ifaddrs-android.cc'))
+android_objects.append(env_thirdparty.SharedObject("#thirdparty/misc/ifaddrs-android.cc"))
 
 lib = env_android.add_shared_library("#bin/libgodot", [android_objects], SHLIBSUFFIX=env["SHLIBSUFFIX"])
 
-lib_arch_dir = ''
-if env['android_arch'] == 'armv7':
-    lib_arch_dir = 'armeabi-v7a'
-elif env['android_arch'] == 'arm64v8':
-    lib_arch_dir = 'arm64-v8a'
-elif env['android_arch'] == 'x86':
-    lib_arch_dir = 'x86'
-elif env['android_arch'] == 'x86_64':
-    lib_arch_dir = 'x86_64'
+lib_arch_dir = ""
+if env["android_arch"] == "armv7":
+    lib_arch_dir = "armeabi-v7a"
+elif env["android_arch"] == "arm64v8":
+    lib_arch_dir = "arm64-v8a"
+elif env["android_arch"] == "x86":
+    lib_arch_dir = "x86"
+elif env["android_arch"] == "x86_64":
+    lib_arch_dir = "x86_64"
 else:
-    print('WARN: Architecture not suitable for embedding into APK; keeping .so at \\bin')
+    print("WARN: Architecture not suitable for embedding into APK; keeping .so at \\bin")
 
-if lib_arch_dir != '':
-    if env['target'] == 'release':
-        lib_type_dir = 'release'
+if lib_arch_dir != "":
+    if env["target"] == "release":
+        lib_type_dir = "release"
     else:  # release_debug, debug
-        lib_type_dir = 'debug'
+        lib_type_dir = "debug"
 
-    out_dir = '#platform/android/java/lib/libs/' + lib_type_dir + '/' + lib_arch_dir
-    env_android.Command(out_dir + '/libgodot_android.so', '#bin/libgodot' + env['SHLIBSUFFIX'], Move("$TARGET", "$SOURCE"))
+    out_dir = "#platform/android/java/lib/libs/" + lib_type_dir + "/" + lib_arch_dir
+    env_android.Command(
+        out_dir + "/libgodot_android.so", "#bin/libgodot" + env["SHLIBSUFFIX"], Move("$TARGET", "$SOURCE")
+    )
 
-    stl_lib_path = str(env['ANDROID_NDK_ROOT']) + '/sources/cxx-stl/llvm-libc++/libs/' + lib_arch_dir + '/libc++_shared.so'
-    env_android.Command(out_dir + '/libc++_shared.so', stl_lib_path, Copy("$TARGET", "$SOURCE"))
+    stl_lib_path = (
+        str(env["ANDROID_NDK_ROOT"]) + "/sources/cxx-stl/llvm-libc++/libs/" + lib_arch_dir + "/libc++_shared.so"
+    )
+    env_android.Command(out_dir + "/libc++_shared.so", stl_lib_path, Copy("$TARGET", "$SOURCE"))
diff --git a/platform/android/detect.py b/platform/android/detect.py
index ff3ca0706c..ed0643e3b3 100644
--- a/platform/android/detect.py
+++ b/platform/android/detect.py
@@ -13,7 +13,7 @@ def get_name():
 
 
 def can_build():
-    return ("ANDROID_NDK_ROOT" in os.environ)
+    return "ANDROID_NDK_ROOT" in os.environ
 
 
 def get_platform(platform):
@@ -24,33 +24,33 @@ def get_opts():
     from SCons.Variables import BoolVariable, EnumVariable
 
     return [
-        ('ANDROID_NDK_ROOT', 'Path to the Android NDK', os.environ.get("ANDROID_NDK_ROOT", 0)),
-        ('ndk_platform', 'Target platform (android-<api>, e.g. "android-18")', "android-18"),
-        EnumVariable('android_arch', 'Target architecture', "armv7", ('armv7', 'arm64v8', 'x86', 'x86_64')),
-        BoolVariable('android_neon', 'Enable NEON support (armv7 only)', True),
+        ("ANDROID_NDK_ROOT", "Path to the Android NDK", os.environ.get("ANDROID_NDK_ROOT", 0)),
+        ("ndk_platform", 'Target platform (android-<api>, e.g. "android-18")', "android-18"),
+        EnumVariable("android_arch", "Target architecture", "armv7", ("armv7", "arm64v8", "x86", "x86_64")),
+        BoolVariable("android_neon", "Enable NEON support (armv7 only)", True),
     ]
 
 
 def get_flags():
     return [
-        ('tools', False),
+        ("tools", False),
     ]
 
 
 def create(env):
-    tools = env['TOOLS']
+    tools = env["TOOLS"]
     if "mingw" in tools:
-        tools.remove('mingw')
+        tools.remove("mingw")
     if "applelink" in tools:
         tools.remove("applelink")
-        env.Tool('gcc')
+        env.Tool("gcc")
     return env.Clone(tools=tools)
 
 
 def configure(env):
     # Workaround for MinGW. See:
     # http://www.scons.org/wiki/LongCmdLinesOnWin32
-    if (os.name == "nt"):
+    if os.name == "nt":
 
         import subprocess
 
@@ -58,8 +58,15 @@ def configure(env):
             # print("SPAWNED : " + cmdline)
             startupinfo = subprocess.STARTUPINFO()
             startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-            proc = subprocess.Popen(cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env)
+            proc = subprocess.Popen(
+                cmdline,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                startupinfo=startupinfo,
+                shell=False,
+                env=env,
+            )
             data, err = proc.communicate()
             rv = proc.wait()
             if rv:
@@ -70,7 +77,7 @@ def configure(env):
 
         def mySpawn(sh, escape, cmd, args, env):
 
-            newargs = ' '.join(args[1:])
+            newargs = " ".join(args[1:])
             cmdline = cmd + " " + newargs
 
             rv = 0
@@ -85,50 +92,54 @@ def configure(env):
 
             return rv
 
-        env['SPAWN'] = mySpawn
+        env["SPAWN"] = mySpawn
 
     # Architecture
 
-    if env['android_arch'] not in ['armv7', 'arm64v8', 'x86', 'x86_64']:
-        env['android_arch'] = 'armv7'
+    if env["android_arch"] not in ["armv7", "arm64v8", "x86", "x86_64"]:
+        env["android_arch"] = "armv7"
 
     neon_text = ""
-    if env["android_arch"] == "armv7" and env['android_neon']:
+    if env["android_arch"] == "armv7" and env["android_neon"]:
         neon_text = " (with NEON)"
-    print("Building for Android (" + env['android_arch'] + ")" + neon_text)
+    print("Building for Android (" + env["android_arch"] + ")" + neon_text)
 
     can_vectorize = True
-    if env['android_arch'] == 'x86':
-        env['ARCH'] = 'arch-x86'
+    if env["android_arch"] == "x86":
+        env["ARCH"] = "arch-x86"
         env.extra_suffix = ".x86" + env.extra_suffix
         target_subpath = "x86-4.9"
         abi_subpath = "i686-linux-android"
         arch_subpath = "x86"
         env["x86_libtheora_opt_gcc"] = True
-    if env['android_arch'] == 'x86_64':
+    if env["android_arch"] == "x86_64":
         if get_platform(env["ndk_platform"]) < 21:
-            print("WARNING: android_arch=x86_64 is not supported by ndk_platform lower than android-21; setting ndk_platform=android-21")
+            print(
+                "WARNING: android_arch=x86_64 is not supported by ndk_platform lower than android-21; setting ndk_platform=android-21"
+            )
             env["ndk_platform"] = "android-21"
-        env['ARCH'] = 'arch-x86_64'
+        env["ARCH"] = "arch-x86_64"
         env.extra_suffix = ".x86_64" + env.extra_suffix
         target_subpath = "x86_64-4.9"
         abi_subpath = "x86_64-linux-android"
         arch_subpath = "x86_64"
         env["x86_libtheora_opt_gcc"] = True
     elif env["android_arch"] == "armv7":
-        env['ARCH'] = 'arch-arm'
+        env["ARCH"] = "arch-arm"
         target_subpath = "arm-linux-androideabi-4.9"
         abi_subpath = "arm-linux-androideabi"
         arch_subpath = "armeabi-v7a"
-        if env['android_neon']:
+        if env["android_neon"]:
             env.extra_suffix = ".armv7.neon" + env.extra_suffix
         else:
             env.extra_suffix = ".armv7" + env.extra_suffix
     elif env["android_arch"] == "arm64v8":
         if get_platform(env["ndk_platform"]) < 21:
-            print("WARNING: android_arch=arm64v8 is not supported by ndk_platform lower than android-21; setting ndk_platform=android-21")
+            print(
+                "WARNING: android_arch=arm64v8 is not supported by ndk_platform lower than android-21; setting ndk_platform=android-21"
+            )
             env["ndk_platform"] = "android-21"
-        env['ARCH'] = 'arch-arm64'
+        env["ARCH"] = "arch-arm64"
         target_subpath = "aarch64-linux-android-4.9"
         abi_subpath = "aarch64-linux-android"
         arch_subpath = "arm64-v8a"
@@ -136,40 +147,40 @@ def configure(env):
 
     # Build type
 
-    if (env["target"].startswith("release")):
-        if (env["optimize"] == "speed"):  # optimize for speed (default)
-            env.Append(LINKFLAGS=['-O2'])
-            env.Append(CCFLAGS=['-O2', '-fomit-frame-pointer'])
-            env.Append(CPPDEFINES=['NDEBUG'])
+    if env["target"].startswith("release"):
+        if env["optimize"] == "speed":  # optimize for speed (default)
+            env.Append(LINKFLAGS=["-O2"])
+            env.Append(CCFLAGS=["-O2", "-fomit-frame-pointer"])
+            env.Append(CPPDEFINES=["NDEBUG"])
         else:  # optimize for size
-            env.Append(CCFLAGS=['-Os'])
-            env.Append(CPPDEFINES=['NDEBUG'])
-            env.Append(LINKFLAGS=['-Os'])
-
-        if (can_vectorize):
-            env.Append(CCFLAGS=['-ftree-vectorize'])
-        if (env["target"] == "release_debug"):
-            env.Append(CPPDEFINES=['DEBUG_ENABLED'])
-    elif (env["target"] == "debug"):
-        env.Append(LINKFLAGS=['-O0'])
-        env.Append(CCFLAGS=['-O0', '-g', '-fno-limit-debug-info'])
-        env.Append(CPPDEFINES=['_DEBUG', 'DEBUG_ENABLED', 'DEBUG_MEMORY_ENABLED'])
-        env.Append(CPPFLAGS=['-UNDEBUG'])
+            env.Append(CCFLAGS=["-Os"])
+            env.Append(CPPDEFINES=["NDEBUG"])
+            env.Append(LINKFLAGS=["-Os"])
+
+        if can_vectorize:
+            env.Append(CCFLAGS=["-ftree-vectorize"])
+        if env["target"] == "release_debug":
+            env.Append(CPPDEFINES=["DEBUG_ENABLED"])
+    elif env["target"] == "debug":
+        env.Append(LINKFLAGS=["-O0"])
+        env.Append(CCFLAGS=["-O0", "-g", "-fno-limit-debug-info"])
+        env.Append(CPPDEFINES=["_DEBUG", "DEBUG_ENABLED", "DEBUG_MEMORY_ENABLED"])
+        env.Append(CPPFLAGS=["-UNDEBUG"])
 
     # Compiler configuration
 
-    env['SHLIBSUFFIX'] = '.so'
+    env["SHLIBSUFFIX"] = ".so"
 
-    if env['PLATFORM'] == 'win32':
-        env.Tool('gcc')
+    if env["PLATFORM"] == "win32":
+        env.Tool("gcc")
         env.use_windows_spawn_fix()
 
-    if (sys.platform.startswith("linux")):
+    if sys.platform.startswith("linux"):
         host_subpath = "linux-x86_64"
-    elif (sys.platform.startswith("darwin")):
+    elif sys.platform.startswith("darwin"):
         host_subpath = "darwin-x86_64"
-    elif (sys.platform.startswith('win')):
-        if (platform.machine().endswith('64')):
+    elif sys.platform.startswith("win"):
+        if platform.machine().endswith("64"):
             host_subpath = "windows-x86_64"
         else:
             host_subpath = "windows"
@@ -179,22 +190,22 @@ def configure(env):
     tools_path = gcc_toolchain_path + "/" + abi_subpath + "/bin"
 
     # For Clang to find NDK tools in preference of those system-wide
-    env.PrependENVPath('PATH', tools_path)
+    env.PrependENVPath("PATH", tools_path)
 
     ccache_path = os.environ.get("CCACHE")
     if ccache_path is None:
-        env['CC'] = compiler_path + '/clang'
-        env['CXX'] = compiler_path + '/clang++'
+        env["CC"] = compiler_path + "/clang"
+        env["CXX"] = compiler_path + "/clang++"
     else:
         # there aren't any ccache wrappers available for Android,
         # to enable caching we need to prepend the path to the ccache binary
-        env['CC'] = ccache_path + ' ' + compiler_path + '/clang'
-        env['CXX'] = ccache_path + ' ' + compiler_path + '/clang++'
-    env['AR'] = tools_path + "/ar"
-    env['RANLIB'] = tools_path + "/ranlib"
-    env['AS'] = tools_path + "/as"
+        env["CC"] = ccache_path + " " + compiler_path + "/clang"
+        env["CXX"] = ccache_path + " " + compiler_path + "/clang++"
+    env["AR"] = tools_path + "/ar"
+    env["RANLIB"] = tools_path + "/ranlib"
+    env["AS"] = tools_path + "/as"
 
-    common_opts = ['-fno-integrated-as', '-gcc-toolchain', gcc_toolchain_path]
+    common_opts = ["-fno-integrated-as", "-gcc-toolchain", gcc_toolchain_path]
 
     # Compile flags
 
@@ -202,14 +213,14 @@ def configure(env):
     env.Append(CPPFLAGS=["-isystem", env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++abi/include"])
 
     # Disable exceptions and rtti on non-tools (template) builds
-    if env['tools']:
-        env.Append(CXXFLAGS=['-frtti'])
+    if env["tools"]:
+        env.Append(CXXFLAGS=["-frtti"])
     else:
-        env.Append(CXXFLAGS=['-fno-rtti', '-fno-exceptions'])
+        env.Append(CXXFLAGS=["-fno-rtti", "-fno-exceptions"])
         # Don't use dynamic_cast, necessary with no-rtti.
-        env.Append(CPPDEFINES=['NO_SAFE_CAST'])
+        env.Append(CPPDEFINES=["NO_SAFE_CAST"])
 
-    lib_sysroot = env["ANDROID_NDK_ROOT"] + "/platforms/" + env['ndk_platform'] + "/" + env['ARCH']
+    lib_sysroot = env["ANDROID_NDK_ROOT"] + "/platforms/" + env["ndk_platform"] + "/" + env["ARCH"]
 
     # Using NDK unified headers (NDK r15+)
     sysroot = env["ANDROID_NDK_ROOT"] + "/sysroot"
@@ -217,35 +228,37 @@ def configure(env):
     env.Append(CPPFLAGS=["-isystem", sysroot + "/usr/include/" + abi_subpath])
     env.Append(CPPFLAGS=["-isystem", env["ANDROID_NDK_ROOT"] + "/sources/android/support/include"])
     # For unified headers this define has to be set manually
-    env.Append(CPPDEFINES=[('__ANDROID_API__', str(get_platform(env['ndk_platform'])))])
+    env.Append(CPPDEFINES=[("__ANDROID_API__", str(get_platform(env["ndk_platform"])))])
 
-    env.Append(CCFLAGS='-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -fvisibility=hidden -fno-strict-aliasing'.split())
-    env.Append(CPPDEFINES=['NO_STATVFS', 'GLES_ENABLED'])
+    env.Append(
+        CCFLAGS="-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -fvisibility=hidden -fno-strict-aliasing".split()
+    )
+    env.Append(CPPDEFINES=["NO_STATVFS", "GLES_ENABLED"])
 
-    env['neon_enabled'] = False
-    if env['android_arch'] == 'x86':
-        target_opts = ['-target', 'i686-none-linux-android']
+    env["neon_enabled"] = False
+    if env["android_arch"] == "x86":
+        target_opts = ["-target", "i686-none-linux-android"]
         # The NDK adds this if targeting API < 21, so we can drop it when Godot targets it at least
-        env.Append(CCFLAGS=['-mstackrealign'])
+        env.Append(CCFLAGS=["-mstackrealign"])
 
-    elif env['android_arch'] == 'x86_64':
-        target_opts = ['-target', 'x86_64-none-linux-android']
+    elif env["android_arch"] == "x86_64":
+        target_opts = ["-target", "x86_64-none-linux-android"]
 
     elif env["android_arch"] == "armv7":
-        target_opts = ['-target', 'armv7-none-linux-androideabi']
-        env.Append(CCFLAGS='-march=armv7-a -mfloat-abi=softfp'.split())
-        env.Append(CPPDEFINES=['__ARM_ARCH_7__', '__ARM_ARCH_7A__'])
-        if env['android_neon']:
-            env['neon_enabled'] = True
-            env.Append(CCFLAGS=['-mfpu=neon'])
-            env.Append(CPPDEFINES=['__ARM_NEON__'])
+        target_opts = ["-target", "armv7-none-linux-androideabi"]
+        env.Append(CCFLAGS="-march=armv7-a -mfloat-abi=softfp".split())
+        env.Append(CPPDEFINES=["__ARM_ARCH_7__", "__ARM_ARCH_7A__"])
+        if env["android_neon"]:
+            env["neon_enabled"] = True
+            env.Append(CCFLAGS=["-mfpu=neon"])
+            env.Append(CPPDEFINES=["__ARM_NEON__"])
         else:
-            env.Append(CCFLAGS=['-mfpu=vfpv3-d16'])
+            env.Append(CCFLAGS=["-mfpu=vfpv3-d16"])
 
     elif env["android_arch"] == "arm64v8":
-        target_opts = ['-target', 'aarch64-none-linux-android']
-        env.Append(CCFLAGS=['-mfix-cortex-a53-835769'])
-        env.Append(CPPDEFINES=['__ARM_ARCH_8A__'])
+        target_opts = ["-target", "aarch64-none-linux-android"]
+        env.Append(CCFLAGS=["-mfix-cortex-a53-835769"])
+        env.Append(CPPDEFINES=["__ARM_ARCH_8A__"])
 
     env.Append(CCFLAGS=target_opts)
     env.Append(CCFLAGS=common_opts)
@@ -254,29 +267,55 @@ def configure(env):
 
     ndk_version = get_ndk_version(env["ANDROID_NDK_ROOT"])
     if ndk_version != None and LooseVersion(ndk_version) >= LooseVersion("17.1.4828580"):
-        env.Append(LINKFLAGS=['-Wl,--exclude-libs,libgcc.a', '-Wl,--exclude-libs,libatomic.a', '-nostdlib++'])
+        env.Append(LINKFLAGS=["-Wl,--exclude-libs,libgcc.a", "-Wl,--exclude-libs,libatomic.a", "-nostdlib++"])
     else:
-        env.Append(LINKFLAGS=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libandroid_support.a"])
-    env.Append(LINKFLAGS=['-shared', '--sysroot=' + lib_sysroot, '-Wl,--warn-shared-textrel'])
+        env.Append(
+            LINKFLAGS=[
+                env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libandroid_support.a"
+            ]
+        )
+    env.Append(LINKFLAGS=["-shared", "--sysroot=" + lib_sysroot, "-Wl,--warn-shared-textrel"])
     env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/"])
-    env.Append(LINKFLAGS=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libc++_shared.so"])
+    env.Append(
+        LINKFLAGS=[env["ANDROID_NDK_ROOT"] + "/sources/cxx-stl/llvm-libc++/libs/" + arch_subpath + "/libc++_shared.so"]
+    )
 
     if env["android_arch"] == "armv7":
-        env.Append(LINKFLAGS='-Wl,--fix-cortex-a8'.split())
-    env.Append(LINKFLAGS='-Wl,--no-undefined -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now'.split())
-    env.Append(LINKFLAGS='-Wl,-soname,libgodot_android.so -Wl,--gc-sections'.split())
+        env.Append(LINKFLAGS="-Wl,--fix-cortex-a8".split())
+    env.Append(LINKFLAGS="-Wl,--no-undefined -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now".split())
+    env.Append(LINKFLAGS="-Wl,-soname,libgodot_android.so -Wl,--gc-sections".split())
 
     env.Append(LINKFLAGS=target_opts)
     env.Append(LINKFLAGS=common_opts)
 
-    env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] + '/toolchains/' + target_subpath + '/prebuilt/' +
-                        host_subpath + '/lib/gcc/' + abi_subpath + '/4.9.x'])
-    env.Append(LIBPATH=[env["ANDROID_NDK_ROOT"] +
-                        '/toolchains/' + target_subpath + '/prebuilt/' + host_subpath + '/' + abi_subpath + '/lib'])
-
-    env.Prepend(CPPPATH=['#platform/android'])
-    env.Append(CPPDEFINES=['ANDROID_ENABLED', 'UNIX_ENABLED', 'NO_FCNTL'])
-    env.Append(LIBS=['OpenSLES', 'EGL', 'GLESv3', 'GLESv2', 'android', 'log', 'z', 'dl'])
+    env.Append(
+        LIBPATH=[
+            env["ANDROID_NDK_ROOT"]
+            + "/toolchains/"
+            + target_subpath
+            + "/prebuilt/"
+            + host_subpath
+            + "/lib/gcc/"
+            + abi_subpath
+            + "/4.9.x"
+        ]
+    )
+    env.Append(
+        LIBPATH=[
+            env["ANDROID_NDK_ROOT"]
+            + "/toolchains/"
+            + target_subpath
+            + "/prebuilt/"
+            + host_subpath
+            + "/"
+            + abi_subpath
+            + "/lib"
+        ]
+    )
+
+    env.Prepend(CPPPATH=["#platform/android"])
+    env.Append(CPPDEFINES=["ANDROID_ENABLED", "UNIX_ENABLED", "NO_FCNTL"])
+    env.Append(LIBS=["OpenSLES", "EGL", "GLESv3", "GLESv2", "android", "log", "z", "dl"])
 
 
 # Return NDK version string in source.properties (adapted from the Chromium project).