#!/usr/bin/env python

"""

Tool for compiling Android toolchain

====================================

This tool intend to replace all the previous tools/ in shell script.

"""

from __future__ import print_function

import sys

from sys import stdout, stderr, platform

from os.path import (join, dirname, realpath, exists, isdir, basename,

expanduser, splitext, split)

from os import listdir, unlink, makedirs, environ, chdir, getcwd, uname

import os

import zipfile

import tarfile

import importlib

import io

import json

import glob

import shutil

import re

import imp

import contextlib

import logging

import shlex

from copy import deepcopy

from functools import wraps

from datetime import datetime

from distutils.spawn import find_executable

from tempfile import mkdtemp

from math import log10

try:

from urllib.request import FancyURLopener

except ImportError:

from urllib import FancyURLopener

try:

from urlparse import urlparse

except ImportError:

from urllib.parse import urlparse

import argparse

from appdirs import user_data_dir

import sh

from colorama import Style as Colo_Style, Fore as Colo_Fore

from collections import defaultdict

class colorama_shim(object):

def __init__(self):

self._dict = defaultdict(str)

def __getattr__(self, key):

return self._dict[key]

Null_Style = Null_Fore = colorama_shim()

if stdout.isatty():

Out_Style = Colo_Style

Out_Fore = Colo_Fore

else:

Out_Style = Null_Style

Out_Fore = Null_Fore

if stderr.isatty():

Err_Style = Colo_Style

Err_Fore = Colo_Fore

else:

Err_Style = Null_Style

Err_Fore = Null_Fore

Fore = Colo_Fore

Style = Colo_Style

user_dir = dirname(realpath(os.path.curdir))

toolchain_dir = dirname(__file__)

sys.path.insert(0, join(toolchain_dir, "tools", "external"))

DEFAULT_ANDROID_API = 15

class LevelDifferentiatingFormatter(logging.Formatter):

def format(self, record):

if record.levelno > 30:

record.msg = '{}{}[ERROR]{}{}: '.format(

Err_Style.BRIGHT, Err_Fore.RED, Err_Fore.RESET,

Err_Style.RESET_ALL) + record.msg

elif record.levelno > 20:

record.msg = '{}{}[WARNING]{}{}: '.format(

Err_Style.BRIGHT, Err_Fore.RED, Err_Fore.RESET,

Err_Style.RESET_ALL) + record.msg

elif record.levelno > 10:

record.msg = '{}[INFO]{}: '.format(

Err_Style.BRIGHT, Err_Style.RESET_ALL) + record.msg

else:

record.msg = '{}{}[DEBUG]{}{}: '.format(

Err_Style.BRIGHT, Err_Fore.LIGHTBLACK_EX, Err_Fore.RESET,

Err_Style.RESET_ALL) + record.msg

return super(LevelDifferentiatingFormatter, self).format(record)

logger = logging.getLogger('p4a')

if not hasattr(logger, 'touched'): # Necessary as importlib reloads

# this, which would add a second

# handler and reset the level

logger.setLevel(logging.INFO)

logger.touched = True

ch = logging.StreamHandler(stderr)

formatter = LevelDifferentiatingFormatter('%(message)s')

ch.setFormatter(formatter)

logger.addHandler(ch)

info = logger.info

debug = logger.debug

warning = logger.warning

error = logger.error

IS_PY3 = sys.version_info[0] >= 3

info(''.join(

[Err_Style.BRIGHT, Err_Fore.RED,

'This python-for-android revamp is an experimental alpha release!',

Err_Style.RESET_ALL]))

info(''.join(

[Err_Fore.RED,

('It should work (mostly), but you may experience '

'missing features or bugs.'),

Err_Style.RESET_ALL]))

def info_main(*args):

logger.info(''.join([Err_Style.BRIGHT, Err_Fore.GREEN] + list(args) +

[Err_Style.RESET_ALL, Err_Fore.RESET]))

def info_notify(s):

info('{}{}{}{}'.format(Err_Style.BRIGHT, Err_Fore.LIGHTBLUE_EX, s,

Err_Style.RESET_ALL))

def pretty_log_dists(dists, log_func=info):

infos = []

for dist in dists:

infos.append('{Fore.GREEN}{Style.BRIGHT}{name}{Style.RESET_ALL}: '

'includes recipes ({Fore.GREEN}{recipes}'

'{Style.RESET_ALL}), built for archs ({Fore.BLUE}'

'{archs}{Style.RESET_ALL})'.format(

name=dist.name, recipes=', '.join(dist.recipes),

archs=', '.join(dist.archs) if dist.archs else 'UNKNOWN',

Fore=Err_Fore, Style=Err_Style))

for line in infos:

log_func('\t' + line)

def shorten_string(string, max_width):

''' make limited length string in form:

"the string is very lo...(and 15 more)"

'''

string_len = len(string)

if string_len <= max_width:

return string

visible = max_width - 16 - int(log10(string_len))

# expected suffix len "...(and XXXXX more)"

return ''.join((string[:visible], '...(and ', str(string_len - visible),

' more)'))

def shprint(command, *args, **kwargs):

'''Runs the command (which should be an sh.Command instance), while

logging the output.'''

kwargs["_iter"] = True

kwargs["_out_bufsize"] = 1

kwargs["_err_to_out"] = True

kwargs["_bg"] = True

is_critical = kwargs.pop('_critical', False)

tail_n = kwargs.pop('_tail', 0)

filter_in = kwargs.pop('_filter', None)

filter_out = kwargs.pop('_filterout', None)

if len(logger.handlers) > 1:

logger.removeHandler(logger.handlers[1])

try:

columns = max(25, int(os.popen('stty size', 'r').read().split()[1]))

except:

columns = 100

command_path = str(command).split('/')

command_string = command_path[-1]

string = ' '.join(['running', command_string] + list(args))

# If logging is not in DEBUG mode, trim the command if necessary

if logger.level > logging.DEBUG:

logger.info('{}{}'.format(shorten_string(string, columns - 12),

Err_Style.RESET_ALL))

else:

logger.debug('{}{}'.format(string, Err_Style.RESET_ALL))

need_closing_newline = False

try:

msg_hdr = ' working: '

msg_width = columns - len(msg_hdr) - 1

output = command(*args, **kwargs)

for line in output:

if logger.level > logging.DEBUG:

msg = line.replace(

'\n', ' ').replace(

'\t', ' ').replace(

'\b', ' ').rstrip()

if msg:

sys.stdout.write(u'{}\r{}{:<{width}}'.format(

Err_Style.RESET_ALL, msg_hdr,

shorten_string(msg, msg_width), width=msg_width))

sys.stdout.flush()

need_closing_newline = True

else:

logger.debug(''.join(['\t', line.rstrip()]))

if need_closing_newline:

sys.stdout.write('{}\r{:>{width}}\r'.format(

Err_Style.RESET_ALL, ' ', width=(columns - 1)))

sys.stdout.flush()

except sh.ErrorReturnCode as err:

if need_closing_newline:

sys.stdout.write('{}\r{:>{width}}\r'.format(

Err_Style.RESET_ALL, ' ', width=(columns - 1)))

sys.stdout.flush()

if tail_n or filter_in or filter_out:

def printtail(out, name, forecolor, tail_n=0,

re_filter_in=None, re_filter_out=None):

lines = out.splitlines()

if re_filter_in is not None:

lines = [l for l in lines if re_filter_in.search(l)]

if re_filter_out is not None:

lines = [l for l in lines if not re_filter_out.search(l)]

if tail_n == 0 or len(lines) <= tail_n:

info('{}:\n{}\t{}{}'.format(

name, forecolor, '\t\n'.join(lines), Out_Fore.RESET))

else:

info('{} (last {} lines of {}):\n{}\t{}{}'.format(

name, tail_n, len(lines),

forecolor, '\t\n'.join(lines[-tail_n:]), Out_Fore.RESET))

printtail(err.stdout, 'STDOUT', Out_Fore.YELLOW, tail_n,

re.compile(filter_in) if filter_in else None,

re.compile(filter_out) if filter_out else None)

printtail(err.stderr, 'STDERR', Err_Fore.RED)

if is_critical:

env = kwargs.get("env")

if env is not None:

info("{}ENV:{}\n{}\n".format(

Err_Fore.YELLOW, Err_Fore.RESET, "\n".join(

"set {}={}".format(n, v) for n, v in env.items())))

info("{}COMMAND:{}\ncd {} && {} {}\n".format(

Err_Fore.YELLOW, Err_Fore.RESET, getcwd(), command, ' '.join(args)))

warning("{}ERROR: {} failed!{}".format(

Err_Fore.RED, command, Err_Fore.RESET))

exit(1)

else:

raise

return output

# shprint(sh.ls, '-lah')

# exit(1)

def add_boolean_option(parser, names, no_names=None,

default=True, dest=None, description=None):

group = parser.add_argument_group(description=description)

if not isinstance(names, (list, tuple)):

names = [names]

if dest is None:

dest = names[0].strip("-").replace("-", "_")

def add_dashes(x):

return x if x.startswith("-") else "--"+x

opts = [add_dashes(x) for x in names]

group.add_argument(

*opts, help=("(this is the default)" if default else None),

dest=dest, action='store_true')

if no_names is None:

def add_no(x):

x = x.lstrip("-")

return ("no_"+x) if "_" in x else ("no-"+x)

no_names = [add_no(x) for x in names]

opts = [add_dashes(x) for x in no_names]

group.add_argument(

*opts, help=(None if default else "(this is the default)"),

dest=dest, action='store_false')

parser.set_defaults(**{dest: default})

def require_prebuilt_dist(func):

'''Decorator for ToolchainCL methods. If present, the method will

automatically make sure a dist has been built before continuing

or, if no dists are present or can be obtained, will raise an

error.

'''

@wraps(func)

def wrapper_func(self, args):

ctx = self.ctx

ctx.set_archs(self._archs)

ctx.prepare_build_environment(user_sdk_dir=self.sdk_dir,

user_ndk_dir=self.ndk_dir,

user_android_api=self.android_api,

user_ndk_ver=self.ndk_version)

dist = self._dist

if dist.needs_build:

info_notify('No dist exists that meets your requirements, '

'so one will be built.')

args = build_dist_from_args(ctx, dist, args)

func(self, args)

return wrapper_func

def get_directory(filename):

'''If the filename ends with a recognised file extension, return the

filename without this extension.'''

if filename.endswith('.tar.gz'):

return basename(filename[:-7])

elif filename.endswith('.tgz'):

return basename(filename[:-4])

elif filename.endswith('.tar.bz2'):

return basename(filename[:-8])

elif filename.endswith('.tbz2'):

return basename(filename[:-5])

elif filename.endswith('.zip'):

return basename(filename[:-4])

info('Unknown file extension for {}'.format(filename))

exit(1)

def which(program, path_env):

'''Locate an executable in the system.'''

import os

def is_exe(fpath):

return os.path.isfile(fpath) and os.access(fpath, os.X_OK)

fpath, fname = os.path.split(program)

if fpath:

if is_exe(program):

return program

else:

for path in path_env.split(os.pathsep):

path = path.strip('"')

exe_file = os.path.join(path, program)

if is_exe(exe_file):

return exe_file

return None

@contextlib.contextmanager

def current_directory(new_dir):

cur_dir = getcwd()

logger.info(''.join((Err_Fore.CYAN, '-> directory context ', new_dir,

Err_Fore.RESET)))

chdir(new_dir)

yield

logger.info(''.join((Err_Fore.CYAN, '<- directory context ', cur_dir,

Err_Fore.RESET)))

chdir(cur_dir)

@contextlib.contextmanager

def temp_directory():

temp_dir = mkdtemp()

try:

logger.debug(''.join((Err_Fore.CYAN, ' + temp directory used ',

temp_dir, Err_Fore.RESET)))

yield temp_dir

finally:

shutil.rmtree(temp_dir)

logger.debug(''.join((Err_Fore.CYAN, ' - temp directory deleted ',

temp_dir, Err_Fore.RESET)))

def cache_execution(f):

def _cache_execution(self, *args, **kwargs):

state = self.ctx.state

key = "{}.{}".format(self.name, f.__name__)

force = kwargs.pop("force", False)

if args:

for arg in args:

key += ".{}".format(arg)

key_time = "{}.at".format(key)

if key in state and not force:

print("# (ignored) {} {}".format(

f.__name__.capitalize(), self.name))

return

print("{} {}".format(f.__name__.capitalize(), self.name))

f(self, *args, **kwargs)

state[key] = True

state[key_time] = str(datetime.utcnow())

return _cache_execution

class ChromeDownloader(FancyURLopener):

version = (

'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 '

'(KHTML, like Gecko) Chrome/28.0.1500.71 Safari/537.36')

urlretrieve = ChromeDownloader().retrieve

class JsonStore(object):

"""Replacement of shelve using json, needed for support python 2 and 3.

"""

def __init__(self, filename):

super(JsonStore, self).__init__()

self.filename = filename

self.data = {}

if exists(filename):

try:

with io.open(filename, encoding='utf-8') as fd:

self.data = json.load(fd)

except ValueError:

print("Unable to read the state.db, content will be replaced.")

def __getitem__(self, key):

return self.data[key]

def __setitem__(self, key, value):

self.data[key] = value

self.sync()

def __delitem__(self, key):

del self.data[key]

self.sync()

def __contains__(self, item):

return item in self.data

def get(self, item, default=None):

return self.data.get(item, default)

def keys(self):

return self.data.keys()

def remove_all(self, prefix):

for key in self.data.keys()[:]:

if not key.startswith(prefix):

continue

del self.data[key]

self.sync()

def sync(self):

# http://stackoverflow.com/questions/12309269/write-json-data-to-file-in-python/14870531#14870531

if IS_PY3:

with open(self.filename, 'w') as fd:

json.dump(self.data, fd, ensure_ascii=False)

else:

with io.open(self.filename, 'w', encoding='utf-8') as fd:

fd.write(unicode(json.dumps(self.data, ensure_ascii=False)))

class Arch(object):

toolchain_prefix = None

'''The prefix for the toolchain dir in the NDK.'''

command_prefix = None

'''The prefix for NDK commands such as gcc.'''

def __init__(self, ctx):

super(Arch, self).__init__()

self.ctx = ctx

def __str__(self):

return self.arch

@property

def include_dirs(self):

return [

"{}/{}".format(

self.ctx.include_dir,

d.format(arch=self))

for d in self.ctx.include_dirs]

def get_env(self):

include_dirs = [

"-I{}/{}".format(

self.ctx.include_dir,

d.format(arch=self))

for d in self.ctx.include_dirs]

env = {}

env["CFLAGS"] = " ".join([

"-DANDROID", "-mandroid", "-fomit-frame-pointer",

"--sysroot", self.ctx.ndk_platform])

env["CXXFLAGS"] = env["CFLAGS"]

env["LDFLAGS"] = " ".join(['-lm'])

py_platform = sys.platform

if py_platform in ['linux2', 'linux3']:

py_platform = 'linux'

toolchain_prefix = self.ctx.toolchain_prefix

toolchain_version = self.ctx.toolchain_version

env['TOOLCHAIN_PREFIX'] = toolchain_prefix

env['TOOLCHAIN_VERSION'] = toolchain_version

if toolchain_prefix == 'x86':

toolchain_prefix = 'i686-linux-android'

print('path is', environ['PATH'])

cc = find_executable('{toolchain_prefix}-gcc'.format(

toolchain_prefix=toolchain_prefix), path=environ['PATH'])

if cc is None:

warning('Couldn\'t find executable for CC. This indicates a '

'problem locating the {} executable in the Android '

'NDK, not that you don\'t have a normal compiler '

'installed. Exiting.')

exit(1)

env['CC'] = '{toolchain_prefix}-gcc {cflags}'.format(

toolchain_prefix=toolchain_prefix,

cflags=env['CFLAGS'])

env['CXX'] = '{toolchain_prefix}-g++ {cxxflags}'.format(

toolchain_prefix=toolchain_prefix,

cxxflags=env['CXXFLAGS'])

env['AR'] = '{}-ar'.format(toolchain_prefix)

env['RANLIB'] = '{}-ranlib'.format(toolchain_prefix)

env['LD'] = '{}-ld'.format(toolchain_prefix)

env['STRIP'] = '{}-strip --strip-unneeded'.format(toolchain_prefix)

env['MAKE'] = 'make -j5'

env['READELF'] = '{}-readelf'.format(toolchain_prefix)

hostpython_recipe = Recipe.get_recipe('hostpython2', self.ctx)

# AND: This hardcodes python version 2.7, needs fixing

env['BUILDLIB_PATH'] = join(

hostpython_recipe.get_build_dir(self.arch),

'build', 'lib.linux-{}-2.7'.format(uname()[-1]))

env['PATH'] = environ['PATH']

env['ARCH'] = self.arch

return env

class ArchARM(Arch):

arch = "armeabi"

toolchain_prefix = 'arm-linux-androideabi'

command_prefix = 'arm-linux-androideabi'

platform_dir = 'arch-arm'

class ArchARMv7_a(ArchARM):

arch = 'armeabi-v7a'

def get_env(self):

env = super(ArchARMv7_a, self).get_env()

env['CFLAGS'] = (env['CFLAGS'] +

' -march=armv7-a -mfloat-abi=softfp -mfpu=vfp -mthumb')

env['CXXFLAGS'] = env['CFLAGS']

return env

class Archx86(Arch):

arch = 'x86'

toolchain_prefix = 'x86'

command_prefix = 'i686-linux-android'

platform_dir = 'arch-x86'

def get_env(self):

env = super(Archx86, self).get_env()

env['CFLAGS'] = (env['CFLAGS'] +

' -march=i686 -mtune=intel -mssse3 -mfpmath=sse -m32')

env['CXXFLAGS'] = env['CFLAGS']

return env

class Archx86_64(Arch):

arch = 'x86_64'

toolchain_prefix = 'x86'

command_prefix = 'x86_64-linux-android'

platform_dir = 'arch-x86'

def get_env(self):

env = super(Archx86_64, self).get_env()

env['CFLAGS'] = (env['CFLAGS'] +

' -march=x86-64 -msse4.2 -mpopcnt -m64 -mtune=intel')

env['CXXFLAGS'] = env['CFLAGS']

return env

class Graph(object):

# Taken from the old python-for-android/depsort

# Modified to include alternative dependencies

def __init__(self):

# `graph`: dict that maps each package to a set of its dependencies.

self.graphs = [{}]

# self.graph = {}

def remove_redundant_graphs(self):

'''Removes possible graphs if they are equivalent to others.'''

graphs = self.graphs

initial_num_graphs = len(graphs)

# Walk the list backwards so that popping elements doesn't

# mess up indexing

for i in range(len(graphs) - 1):

graph = graphs[initial_num_graphs - 1 - i]

for j in range(1, len(graphs)):

comparison_graph = graphs[initial_num_graphs - 1 - j]

if set(comparison_graph.keys()) == set(graph.keys()):

graphs.pop(initial_num_graphs - 1 - i)

break

def add(self, dependent, dependency):

"""Add a dependency relationship to the graph"""

if isinstance(dependency, (tuple, list)):

for graph in self.graphs[:]:

for dep in dependency[1:]:

new_graph = deepcopy(graph)

self._add(new_graph, dependent, dep)

self.graphs.append(new_graph)

self._add(graph, dependent, dependency[0])

else:

for graph in self.graphs:

self._add(graph, dependent, dependency)

self.remove_redundant_graphs()

def _add(self, graph, dependent, dependency):

'''Add a dependency relationship to a specific graph, where dependency

must be a single dependency, not a list or tuple.

'''

graph.setdefault(dependent, set())

graph.setdefault(dependency, set())

if dependent != dependency:

graph[dependent].add(dependency)

def conflicts(self, conflict):

graphs = self.graphs

for i in range(len(graphs)):

graph = graphs[len(graphs) - 1 - i]

if conflict in graph:

graphs.pop(len(graphs) - 1 - i)

return len(graphs) == 0

def remove_remaining_conflicts(self, ctx):

# It's unpleasant to have to pass ctx as an argument...

'''Checks all possible graphs for conflicts that have arisen during

the additon of alternative repice branches, as these are not checked

for conflicts at the time.'''

new_graphs = []

for i, graph in enumerate(self.graphs):

for name in graph.keys():

recipe = Recipe.get_recipe(name, ctx)

if any([c in graph for c in recipe.conflicts]):

break

else:

new_graphs.append(graph)

self.graphs = new_graphs

def add_optional(self, dependent, dependency):

"""Add an optional (ordering only) dependency relationship to the graph

Only call this after all mandatory requirements are added

"""

for graph in self.graphs:

if dependent in graph and dependency in graph:

self._add(graph, dependent, dependency)

def find_order(self, index=0):

"""Do a topological sort on a dependency graph

:Parameters:

:Returns:

iterator, sorted items form first to last

"""

graph = self.graphs[index]

graph = dict((k, set(v)) for k, v in graph.items())

while graph:

# Find all items without a parent

leftmost = [l for l, s in graph.items() if not s]

if not leftmost:

raise ValueError('Dependency cycle detected! %s' % graph)

# If there is more than one, sort them for predictable order

leftmost.sort()

for result in leftmost:

# Yield and remove them from the graph

yield result

graph.pop(result)

for bset in graph.values():

bset.discard(result)

class Context(object):

'''A build context. If anything will be built, an instance this class

will be instantiated and used to hold all the build state.'''

env = environ.copy()

root_dir = None # the filepath of toolchain.py

storage_dir = None # the root dir where builds and dists will be stored

build_dir = None # in which bootstraps are copied for building and recipes are built

dist_dir = None # the Android project folder where everything ends up

libs_dir = None # where Android libs are cached after build but

# before being placed in dists

aars_dir = None

javaclass_dir = None

ccache = None # whether to use ccache

cython = None # the cython interpreter name

ndk_platform = None # the ndk platform directory

dist_name = None # should be deprecated in favour of self.dist.dist_name

bootstrap = None

bootstrap_build_dir = None

recipe_build_order = None # Will hold the list of all built recipes

@property

def packages_path(self):

'''Where packages are downloaded before being unpacked'''

return join(self.storage_dir, 'packages')

@property

def templates_dir(self):

return join(self.root_dir, 'templates')

@property

def libs_dir(self):

# Was previously hardcoded as self.build_dir/libs

dir = join(self.build_dir, 'libs_collections',

self.bootstrap.distribution.name)

ensure_dir(dir)

return dir

@property

def javaclass_dir(self):

# Was previously hardcoded as self.build_dir/java

dir = join(self.build_dir, 'javaclasses',

self.bootstrap.distribution.name)

ensure_dir(dir)

return dir

@property

def aars_dir(self):

dir = join(self.build_dir, 'aars', self.bootstrap.distribution.name)

ensure_dir(dir)

return dir

@property

def python_installs_dir(self):

dir = join(self.build_dir, 'python-installs')

ensure_dir(dir)

return dir

def get_python_install_dir(self):

dir = join(self.python_installs_dir, self.bootstrap.distribution.name)

return dir

def setup_dirs(self):

'''Calculates all the storage and build dirs, and makes sure

the directories exist where necessary.'''

self.root_dir = realpath(dirname(__file__))

# AND: TODO: Allow the user to set the build_dir

self.storage_dir = user_data_dir('python-for-android')

self.build_dir = join(self.storage_dir, 'build')

self.dist_dir = join(self.storage_dir, 'dists')

ensure_dir(self.storage_dir)

ensure_dir(self.build_dir)

ensure_dir(self.dist_dir)

@property

def android_api(self):

'''The Android API being targeted.'''

if self._android_api is None:

raise ValueError('Tried to access android_api but it has not '

'been set - this should not happen, something '

'went wrong!')

return self._android_api

@android_api.setter

def android_api(self, value):

self._android_api = value

@property

def ndk_ver(self):

'''The version of the NDK being used for compilation.'''

if self._ndk_ver is None:

raise ValueError('Tried to access android_api but it has not '

'been set - this should not happen, something '

'went wrong!')

return self._ndk_ver

@ndk_ver.setter

def ndk_ver(self, value):

self._ndk_ver = value

@property

def sdk_dir(self):

'''The path to the Android SDK.'''

if self._sdk_dir is None:

raise ValueError('Tried to access android_api but it has not '

'been set - this should not happen, something '

'went wrong!')

return self._sdk_dir

@sdk_dir.setter

def sdk_dir(self, value):

self._sdk_dir = value

@property

def ndk_dir(self):

'''The path to the Android NDK.'''

if self._ndk_dir is None:

raise ValueError('Tried to access android_api but it has not '

'been set - this should not happen, something '

'went wrong!')

return self._ndk_dir

@ndk_dir.setter

def ndk_dir(self, value):

self._ndk_dir = value

def prepare_build_environment(self, user_sdk_dir, user_ndk_dir,

user_android_api, user_ndk_ver):

'''Checks that build dependencies exist and sets internal variables

for the Android SDK etc.

..warning:: This *must* be called before trying any build stuff

'''

if self._build_env_prepared:

return

# AND: This needs revamping to carefully check each dependency

# in turn

ok = True

# Work out where the Android SDK is

sdk_dir = None

if user_sdk_dir:

sdk_dir = user_sdk_dir

if sdk_dir is None: # This is the old P4A-specific var

sdk_dir = environ.get('ANDROIDSDK', None)

if sdk_dir is None: # This seems used more conventionally

sdk_dir = environ.get('ANDROID_HOME', None)

if sdk_dir is None: # Checks in the buildozer SDK dir, useful

# # for debug tests of p4a

possible_dirs = glob.glob(expanduser(join(

'~', '.buildozer', 'android', 'platform', 'android-sdk-*')))

if possible_dirs:

info('Found possible SDK dirs in buildozer dir: {}'.format(

', '.join([d.split(os.sep)[-1] for d in possible_dirs])))

info('Will attempt to use SDK at {}'.format(possible_dirs[0]))

warning('This SDK lookup is intended for debug only, if you '

'use python-for-android much you should probably '

'maintain your own SDK download.')

sdk_dir = possible_dirs[0]

if sdk_dir is None:

warning('Android SDK dir was not specified, exiting.')

exit(1)

self.sdk_dir = realpath(sdk_dir)

# Check what Android API we're using

android_api = None

if user_android_api:

android_api = user_android_api

if android_api is not None:

info('Getting Android API version from user argument')

if android_api is None:

android_api = environ.get('ANDROIDAPI', None)

if android_api is not None:

info('Found Android API target in $ANDROIDAPI')

if android_api is None:

info('Android API target was not set manually, using '

'the default of {}'.format(DEFAULT_ANDROID_API))

android_api = DEFAULT_ANDROID_API

android_api = int(android_api)

self.android_api = android_api

android = sh.Command(join(sdk_dir, 'tools', 'android'))

targets = android('list').stdout.split('\n')

apis = [s for s in targets if re.match(r'^ *API level: ', s)]

apis = [re.findall(r'[0-9]+', s) for s in apis]

apis = [int(s[0]) for s in apis if s]

info('Available Android APIs are ({})'.format(

', '.join(map(str, apis))))

if android_api in apis:

info(('Requested API target {} is available, '

'continuing.').format(android_api))

else:

warning(('Requested API target {} is not available, install '

'it with the SDK android tool.').format(android_api))

warning('Exiting.')

exit(1)

# Find the Android NDK

# Could also use ANDROID_NDK, but doesn't look like many tools use this

ndk_dir = None

if user_ndk_dir:

ndk_dir = user_ndk_dir

if ndk_dir is not None:

info('Getting NDK dir from from user argument')

if ndk_dir is None: # The old P4A-specific dir

ndk_dir = environ.get('ANDROIDNDK', None)

if ndk_dir is not None:

info('Found NDK dir in $ANDROIDNDK')

if ndk_dir is None: # Apparently the most common convention

ndk_dir = environ.get('NDK_HOME', None)

if ndk_dir is not None:

info('Found NDK dir in $NDK_HOME')

if ndk_dir is None: # Another convention (with maven?)

ndk_dir = environ.get('ANDROID_NDK_HOME', None)

if ndk_dir is not None:

info('Found NDK dir in $ANDROID_NDK_HOME')

if ndk_dir is None: # Checks in the buildozer NDK dir, useful

# # for debug tests of p4a

possible_dirs = glob.glob(expanduser(join(

'~', '.buildozer', 'android', 'platform', 'android-ndk-r*')))

if possible_dirs:

info('Found possible NDK dirs in buildozer dir: {}'.format(

', '.join([d.split(os.sep)[-1] for d in possible_dirs])))

info('Will attempt to use NDK at {}'.format(possible_dirs[0]))

warning('This NDK lookup is intended for debug only, if you '

'use python-for-android much you should probably '

'maintain your own NDK download.')

ndk_dir = possible_dirs[0]

if ndk_dir is None:

warning('Android NDK dir was not specified, exiting.')

exit(1)

self.ndk_dir = realpath(ndk_dir)

# Find the NDK version, and check it against what the NDK dir

# seems to report

ndk_ver = None

if user_ndk_ver:

ndk_ver = user_ndk_ver

if ndk_dir is not None:

info('Got NDK version from from user argument')

if ndk_ver is None:

ndk_ver = environ.get('ANDROIDNDKVER', None)

if ndk_dir is not None:

info('Got NDK version from $ANDROIDNDKVER')

try:

with open(join(ndk_dir, 'RELEASE.TXT')) as fileh:

reported_ndk_ver = fileh.read().split(' ')[0]

except IOError:

pass

else:

if ndk_ver is None:

ndk_ver = reported_ndk_ver

info(('Got Android NDK version from the NDK dir: '

'it is {}').format(ndk_ver))

else:

if ndk_ver != reported_ndk_ver:

warning('NDK version was set as {}, but checking '

'the NDK dir claims it is {}.'.format(

ndk_ver, reported_ndk_ver))

warning('The build will try to continue, but it may '

'fail and you should check '

'that your setting is correct.')

warning('If the NDK dir result is correct, you don\'t '

'need to manually set the NDK ver.')

if ndk_ver is None:

warning('Android NDK version could not be found, exiting.')

self.ndk_ver = ndk_ver

virtualenv = None

if virtualenv is None:

virtualenv = sh.which('virtualenv2')

if virtualenv is None:

virtualenv = sh.which('virtualenv-2.7')

if virtualenv is None:

virtualenv = sh.which('virtualenv')

if virtualenv is None:

raise IOError('Couldn\'t find a virtualenv executable, '

'you must install this to use p4a.')

self.virtualenv = virtualenv

info('Found virtualenv at {}'.format(virtualenv))

# path to some tools

self.ccache = sh.which("ccache")

if not self.ccache:

info('ccache is missing, the build will not be optimized in the '

'future.')

for cython_fn in ("cython2", "cython-2.7", "cython"):

cython = sh.which(cython_fn)

if cython:

self.cython = cython

break