#!/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, platform

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

expanduser)

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

import os

import zipfile

import importlib

import io

import json

import glob

import shutil

import re

import imp

import contextlib

import logging

from copy import deepcopy

from functools import wraps

from datetime import datetime

from distutils.spawn import find_executable

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, Fore

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 > 20:

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

Style.BRIGHT, Fore.RED, Fore.RESET, Style.RESET_ALL

) + record.msg

elif record.levelno > 10:

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

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

else:

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

Style.BRIGHT, Fore.LIGHTBLACK_EX, Fore.RESET, 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(stdout)

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

ch.setFormatter(formatter)

logger.addHandler(ch)

info = logger.info

debug = logger.debug

warning = logger.warning

IS_PY3 = sys.version_info[0] >= 3

info(''.join([Style.BRIGHT, Fore.RED,

'This python-for-android revamp is an experimental alpha '

'release!',

Style.RESET_ALL]))

info(''.join([Fore.RED,

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

'missing features or bugs.'),

Style.RESET_ALL]))

def info_main(*args):

logger.info(''.join([Style.BRIGHT, Fore.GREEN] + list(args) +

[Style.RESET_ALL, Fore.RESET]))

def info_notify(s):

info('{}{}{}{}'.format(Style.BRIGHT, Fore.LIGHTBLUE_EX, s, 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})'.format(

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

Fore=Fore, Style=Style))

for line in infos:

log_func('\t' + line)

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

if len(logger.handlers) > 1:

logger.removeHandler(logger.handlers[1])

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:

short_string = string

if len(string) > 100:

short_string = string[:100] + '... (and {} more)'.format(

len(string) - 100)

logger.info(short_string + Style.RESET_ALL)

else:

logger.debug(string + Style.RESET_ALL)

output = command(*args, **kwargs)

need_closing_newline = False

for line in output:

if logger.level > logging.DEBUG:

string = ''.join([Style.RESET_ALL, '\r', ' '*11, 'working ... ',

line[:100].replace('\n', '').rstrip(), ' ...'])

if len(string) < 20:

continue

if len(string) < 120:

string = string + ' '*(120 - len(string))

sys.stdout.write(string)

sys.stdout.flush()

need_closing_newline = True

else:

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

if logger.level > logging.DEBUG and need_closing_newline:

print()

return output

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

# exit(1)

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.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((Fore.CYAN, '-> directory context ', new_dir,

Fore.RESET)))

chdir(new_dir)

yield

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

Fore.RESET)))

chdir(cur_dir)

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):

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):

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

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

# AND: This also hardcodes armeabi, which isn't even correct,

# don't forget to fix!

env['BUILDLIB_PATH'] = join(

hostpython_recipe.get_build_dir('armeabi'),

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

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

# AND: This stuff is set elsewhere in distribute.sh. Does that matter?

env['ARCH'] = self.arch

# env['LIBLINK_PATH'] = join(self.ctx.build_dir, 'other_builds',

# 'objects')

# ensure_dir(env['LIBLINK_PATH']) # AND: This should be elsewhere

return env

class ArchAndroid(Arch):

arch = "armeabi"

# class ArchSimulator(Arch):

# sdk = "iphonesimulator"

# arch = "i386"

# triple = "i386-apple-darwin11"

# version_min = "-miphoneos-version-min=6.0.0"

# sysroot = sh.xcrun("--sdk", "iphonesimulator", "--show-sdk-path").strip()

# class Arch64Simulator(Arch):

# sdk = "iphonesimulator"

# arch = "x86_64"

# triple = "x86_64-apple-darwin13"

# version_min = "-miphoneos-version-min=7.0"

# sysroot = sh.xcrun("--sdk", "iphonesimulator", "--show-sdk-path").strip()

# class ArchIOS(Arch):

# sdk = "iphoneos"

# arch = "armv7"

# triple = "arm-apple-darwin11"

# version_min = "-miphoneos-version-min=6.0.0"

# sysroot = sh.xcrun("--sdk", "iphoneos", "--show-sdk-path").strip()

# class Arch64IOS(Arch):

# sdk = "iphoneos"

# arch = "arm64"

# triple = "aarch64-apple-darwin13"

# version_min = "-miphoneos-version-min=7.0"

# sysroot = sh.xcrun("--sdk", "iphoneos", "--show-sdk-path").strip()

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

# in which bootstraps are copied for building and recipes are built

build_dir = None

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

# where Android libs are cached after build but before being placed

# in dists

libs_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 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)

# Checks in the buildozer SDK dir, useful for debug tests of p4a

if sdk_dir is None:

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)

# AND: If the android api target doesn't exist, we should

# offer to install it here

# 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')

# Checks in the buildozer NDK dir, useful for debug tests of p4a

if ndk_dir is None:

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

self.ndk_platform = join(

self.ndk_dir,

'platforms',

'android-{}'.format(self.android_api),

'arch-arm')

if not exists(self.ndk_platform):

warning('ndk_platform doesn\'t exist')

ok = False

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

if not self.cython:

ok = False

warning("Missing requirement: cython is not installed")

# Modify the path so that sh finds modules appropriately

py_platform = sys.platform

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

py_platform = 'linux'

if self.ndk_ver == 'r5b':

toolchain_prefix = 'arm-eabi'

elif self.ndk_ver[:2] in ('r7', 'r8', 'r9'):

toolchain_prefix = 'arm-linux-androideabi'

elif self.ndk_ver[:3] == 'r10':

toolchain_prefix = 'arm-linux-androideabi'

else:

warning('Error: NDK not supported by these tools?')

exit(1)

toolchain_versions = []

toolchain_path = join(self.ndk_dir, 'toolchains')

if os.path.isdir(toolchain_path):

toolchain_contents = os.listdir(toolchain_path)

for toolchain_content in toolchain_contents:

if (

toolchain_content.startswith(toolchain_prefix) and

os.path.isdir(

os.path.join(toolchain_path, toolchain_content))

):

toolchain_version = toolchain_content[

len(toolchain_prefix)+1:]

debug('Found toolchain version: {}'.format(

toolchain_version))

toolchain_versions.append(toolchain_version)

else:

warning('Could not find toolchain subdirectory!')

ok = False

toolchain_versions.sort()

toolchain_versions_gcc = []

for toolchain_version in toolchain_versions:

# GCC toolchains begin with a number

if toolchain_version[0].isdigit():

toolchain_versions_gcc.append(toolchain_version)

if toolchain_versions:

info('Found the following toolchain versions: {}'

.format(toolchain_versions))

info('Picking the latest gcc toolchain, here {}'

.format(toolchain_versions_gcc[-1]))

toolchain_version = toolchain_versions_gcc[-1]

else:

warning('Could not find any toolchain for {}!'

.format(toolchain_prefix))

ok = False

self.toolchain_prefix = toolchain_prefix

self.toolchain_version = toolchain_version

environ['PATH'] = (

'{ndk_dir}/toolchains/{toolchain_prefix}-{toolchain_version}/'

'prebuilt/{py_platform}-x86/bin/:{ndk_dir}/toolchains/'

'{toolchain_prefix}-{toolchain_version}/prebuilt/'

'{py_platform}-x86_64/bin/:{ndk_dir}:{sdk_dir}/'

'tools:{path}').format(

sdk_dir=self.sdk_dir, ndk_dir=self.ndk_dir,

toolchain_prefix=toolchain_prefix,

toolchain_version=toolchain_version,

py_platform=py_platform, path=environ.get('PATH'))

# AND: Are these necessary? Where to check for and and ndk-build?

# check the basic tools

for executable in ("pkg-config", "autoconf", "automake", "libtoolize",

"tar", "bzip2", "unzip", "make", "gcc", "g++"):

if not sh.which(executable):

warning("Missing executable: {} is not installed".format(

executable))

if not ok:

sys.exit(1)

def __init__(self):

super(Context, self).__init__()

self.include_dirs = []

self._build_env_prepared = False

self._sdk_dir = None

self._ndk_dir = None

self._android_api = None

self._ndk_ver = None

self.toolchain_prefix = None

self.toolchain_version = None

# root of the toolchain

self.setup_dirs()

# AND: Currently only the Android architecture is supported

self.archs = (

ArchAndroid(self),

)

ensure_dir(join(self.build_dir, 'bootstrap_builds'))

# where everything else is built

ensure_dir(join(self.build_dir, 'other_builds'))

# # remove the most obvious flags that can break the compilation

self.env.pop("LDFLAGS", None)

self.env.pop("ARCHFLAGS", None)

self.env.pop("CFLAGS", None)

# set the state

self.state = JsonStore(join(self.dist_dir, "state.db"))

def prepare_bootstrap(self, bs):

bs.ctx = self

self.bootstrap = bs

self.bootstrap.prepare_build_dir()

self.bootstrap_build_dir = self.bootstrap.build_dir

def prepare_dist(self, name):

self.dist_name = name

self.bootstrap.prepare_dist_dir(self.dist_name)

def get_site_packages_dir(self, arch=None):

'''Returns the location of site-packages in the python-install build

dir.

'''

# AND: This *must* be replaced with something more general in

# order to support multiple python versions and/or multiple

# archs.

return join(self.get_python_install_dir(),

'lib', 'python2.7', 'site-packages')

def get_libs_dir(self, arch):

'''The libs dir for a given arch.'''

ensure_dir(join(self.libs_dir, arch))

# AND: See warning:

return join(self.libs_dir, arch)

class Distribution(object):

'''State container for information about a distribution (i.e. an

Android project).

This is separate from a Bootstrap because the Bootstrap is

concerned with building and populating the dist directory, whereas

the dist itself could also come from e.g. a binary download.

'''

ctx = None

name = None # A name identifying the dist. May not be None.

needs_build = False # Whether the dist needs compiling

url = None

dist_dir = None # Where the dist dir ultimately is. Should not be None.