for root, dirnames, filenames in walk(src_root):

for filename in filenames:

subdir = normpath(root.replace(src_root, ""))

if subdir.startswith(sep): # ensure it is relative

subdir = subdir[1:]

dest_dir = join(dest_root, subdir)

if not os.path.exists(dest_dir):

os.makedirs(dest_dir)

src_file = join(root, filename)

dest_file = join(dest_dir, filename)

if os.path.isfile(src_file):

if override and os.path.exists(dest_file):

os.unlink(dest_file)

if not os.path.exists(dest_file):

if symlink:

os.symlink(src_file, dest_file)

else:

shutil.copy(src_file, dest_file)

else:

def rank_bootstrap(bootstrap):

""" Returns a ranking index for each bootstrap,

if bootstrap.name in default_recipe_priorities:

return default_recipe_priorities.index(bootstrap.name) + 1

return 0

# Rank bootstraps in order:

rank_a = rank_bootstrap(a)

rank_b = rank_bootstrap(b)

if rank_a != rank_b:

return (rank_b - rank_a)

else:

if a.name < b.name: # alphabetic sort for determinism

return -1

else:

'''An Android project template, containing recipe stuff for

jni_subdir = '/jni'

ctx = None

bootstrap_dir = None

build_dir = None

dist_name = None

distribution = None

# All bootstraps should include Python in some way:

recipe_depends = ['python3', 'android']

can_be_chosen_automatically = True

'''Determines whether the bootstrap can be chosen as one that

# Other things a Bootstrap might need to track (maybe separately):

# ndk_main.c

# whitelist.txt

# blacklist.txt

@property

def dist_dir(self):

'''The dist dir at which to place the finished distribution.'''

if self.distribution is None:

raise BuildInterruptingException(

'Internal error: tried to access {}.dist_dir, but {}.distribution '

'is None'.format(self, self))

return self.distribution.dist_dir

@property

def jni_dir(self):

return self.name + self.jni_subdir

def check_recipe_choices(self):

'''Checks what recipes are being built to see which of the alternative

recipes = []

built_recipes = self.ctx.recipe_build_order or []

for recipe in self.recipe_depends:

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

for alternative in recipe:

if alternative in built_recipes:

recipes.append(alternative)

break

return sorted(recipes)

def get_build_dir_name(self):

choices = self.check_recipe_choices()

dir_name = '-'.join([self.name] + choices)

return dir_name

def get_build_dir(self):

return join(self.ctx.build_dir, 'bootstrap_builds', self.get_build_dir_name())

def get_dist_dir(self, name):

return join(self.ctx.dist_dir, name)

@property

def name(self):

modname = self.__class__.__module__

return modname.split(".", 2)[-1]

def get_bootstrap_dirs(self):

"""get all bootstrap directories, following the MRO path"""

# get all bootstrap names along the __mro__, cutting off Bootstrap and object

classes = self.__class__.__mro__[:-2]

bootstrap_names = [cls.name for cls in classes] + ['common']

bootstrap_dirs = [

join(self.ctx.root_dir, 'bootstraps', bootstrap_name)

for bootstrap_name in reversed(bootstrap_names)

]

return bootstrap_dirs

def _copy_in_final_files(self):

if self.name in SDL_BOOTSTRAPS:

# Get the paths for copying SDL's java source code:

sdl_recipe = Recipe.get_recipe(self.name, self.ctx)

sdl_build_dir = sdl_recipe.get_jni_dir()

src_dir = join(sdl_build_dir, "SDL", "android-project",

"app", "src", "main", "java",

"org", "libsdl", "app")

target_dir = join(self.dist_dir, 'src', 'main', 'java', 'org',

'libsdl', 'app')

# Do actual copying:

info('Copying in SDL .java files from: ' + str(src_dir))

if not os.path.exists(target_dir):

os.makedirs(target_dir)

copy_files(src_dir, target_dir, override=True)

def prepare_build_dir(self):

"""Ensure that a build dir exists for the recipe. This same single

bootstrap_dirs = self.get_bootstrap_dirs()

# now do a cumulative copy of all bootstrap dirs

self.build_dir = self.get_build_dir()

for bootstrap_dir in bootstrap_dirs:

copy_files(join(bootstrap_dir, 'build'), self.build_dir, symlink=self.ctx.symlink_bootstrap_files)

with current_directory(self.build_dir):

with open('project.properties', 'w') as fileh:

fileh.write('target=android-{}'.format(self.ctx.android_api))

def prepare_dist_dir(self):

ensure_dir(self.dist_dir)

def _assemble_distribution_for_arch(self, arch):

"""Per-architecture distribution assembly.

self.distribute_libs(arch, [self.ctx.get_libs_dir(arch.arch)])

self.distribute_aars(arch)

python_bundle_dir = join(f'_python_bundle__{arch.arch}', '_python_bundle')

ensure_dir(python_bundle_dir)

site_packages_dir = self.ctx.python_recipe.create_python_bundle(

join(self.dist_dir, python_bundle_dir), arch)

if not self.ctx.with_debug_symbols:

self.strip_libraries(arch)

self.fry_eggs(site_packages_dir)

def assemble_distribution(self):

"""Assemble the distribution by copying files and creating Python bundle.

info_main(f'# Creating Android project ({self.name})')

rmdir(self.dist_dir)

shprint(sh.cp, '-r', self.build_dir, self.dist_dir)

with current_directory(self.dist_dir):

with open('local.properties', 'w') as fileh:

fileh.write('sdk.dir={}'.format(self.ctx.sdk_dir))

with current_directory(self.dist_dir):

info('Copying Python distribution')

self.distribute_javaclasses(self.ctx.javaclass_dir,

dest_dir=join("src", "main", "java"))

for arch in self.ctx.archs:

self._assemble_distribution_for_arch(arch)

if 'sqlite3' not in self.ctx.recipe_build_order:

with open('blacklist.txt', 'a') as fileh:

fileh.write('\nsqlite3/*\nlib-dynload/_sqlite3.so\n')

self._copy_in_final_files()

self.distribution.save_info(self.dist_dir)

@classmethod

def all_bootstraps(cls):

'''Find all the available bootstraps and return them.'''

forbidden_dirs = ('__pycache__', 'common', '_sdl_common')

bootstraps_dir = join(dirname(__file__), 'bootstraps')

result = set()

for name in listdir(bootstraps_dir):

if name in forbidden_dirs:

continue

filen = join(bootstraps_dir, name)

if isdir(filen):

result.add(name)

return result

@classmethod

def get_usable_bootstraps_for_recipes(cls, recipes, ctx):

'''Returns all bootstrap whose recipe requirements do not conflict

info('Trying to find a bootstrap that matches the given recipes.')

bootstraps = [cls.get_bootstrap(name, ctx)

for name in cls.all_bootstraps()]

acceptable_bootstraps = set()

# Find out which bootstraps are acceptable:

for bs in bootstraps:

if not bs.can_be_chosen_automatically:

continue

possible_dependency_lists = expand_dependencies(bs.recipe_depends, ctx)

for possible_dependencies in possible_dependency_lists:

ok = True

# Check if the bootstap's dependencies have an internal conflict:

for recipe in possible_dependencies:

recipe = Recipe.get_recipe(recipe, ctx)

if any(conflict in recipes for conflict in recipe.conflicts):

ok = False

break

# Check if bootstrap's dependencies conflict with chosen

# packages:

for recipe in recipes:

try:

recipe = Recipe.get_recipe(recipe, ctx)

except ValueError:

conflicts = []

else:

conflicts = recipe.conflicts

if any(conflict in possible_dependencies

for conflict in conflicts):

ok = False

break

if ok and bs not in acceptable_bootstraps:

acceptable_bootstraps.add(bs)

info('Found {} acceptable bootstraps: {}'.format(

len(acceptable_bootstraps),

[bs.name for bs in acceptable_bootstraps]))

return acceptable_bootstraps

@classmethod

def get_bootstrap_from_recipes(cls, recipes, ctx):

'''Picks a single recommended default bootstrap out of

known_web_packages = {"flask"} # to pick webview over service_only

recipes_with_deps_lists = expand_dependencies(recipes, ctx)

acceptable_bootstraps = cls.get_usable_bootstraps_for_recipes(

recipes, ctx

)

def have_dependency_in_recipes(dep):

for dep_list in recipes_with_deps_lists:

if dep in dep_list:

return True

return False

# Special rule: return SDL2 bootstrap if there's an sdl2 dep:

if (have_dependency_in_recipes("sdl2") and

"sdl2" in [b.name for b in acceptable_bootstraps]

):

info('Using sdl2 bootstrap since it is in dependencies')

return cls.get_bootstrap("sdl2", ctx)

# Special rule: return SDL3 bootstrap if there's an sdl3 dep:

if (have_dependency_in_recipes("sdl3") and

"sdl3" in [b.name for b in acceptable_bootstraps]

):

info('Using sdl3 bootstrap since it is in dependencies')

return cls.get_bootstrap("sdl3", ctx)

# Special rule: return "webview" if we depend on common web recipe:

for possible_web_dep in known_web_packages:

if have_dependency_in_recipes(possible_web_dep):

# We have a web package dep!

if "webview" in [b.name for b in acceptable_bootstraps]:

info('Using webview bootstrap since common web packages '

'were found {}'.format(

known_web_packages.intersection(recipes)

))

return cls.get_bootstrap("webview", ctx)

prioritized_acceptable_bootstraps = sorted(

list(acceptable_bootstraps),

key=functools.cmp_to_key(_cmp_bootstraps_by_priority)

)

if prioritized_acceptable_bootstraps:

info('Using the highest ranked/first of these: {}'

.format(prioritized_acceptable_bootstraps[0].name))

return prioritized_acceptable_bootstraps[0]

return None

@classmethod

def get_bootstrap(cls, name, ctx):

'''Returns an instance of a bootstrap with the given name.

if name is None:

return None

if not hasattr(cls, 'bootstraps'):

cls.bootstraps = {}

if name in cls.bootstraps:

return cls.bootstraps[name]

mod = importlib.import_module('pythonforandroid.bootstraps.{}'

.format(name))

if len(logger.handlers) > 1:

logger.removeHandler(logger.handlers[1])

bootstrap = mod.bootstrap

bootstrap.bootstrap_dir = join(ctx.root_dir, 'bootstraps', name)

bootstrap.ctx = ctx

return bootstrap

def distribute_libs(self, arch, src_dirs, wildcard='*', dest_dir="libs"):

'''Copy existing arch libs from build dirs to current dist dir.'''

info('Copying libs')

tgt_dir = join(dest_dir, arch.arch)

ensure_dir(tgt_dir)

for src_dir in src_dirs:

libs = glob.glob(join(src_dir, wildcard))

if libs:

shprint(sh.cp, '-a', *libs, tgt_dir)

def distribute_javaclasses(self, javaclass_dir, dest_dir="src"):

'''Copy existing javaclasses from build dir to current dist dir.'''

info('Copying java files')

ensure_dir(dest_dir)

filenames = glob.glob(javaclass_dir)

shprint(sh.cp, '-a', *filenames, dest_dir)

def distribute_aars(self, arch):

'''Process existing .aar bundles and copy to current dist dir.'''

info('Unpacking aars')

for aar in glob.glob(join(self.ctx.aars_dir, '*.aar')):

self._unpack_aar(aar, arch)

def _unpack_aar(self, aar, arch):

'''Unpack content of .aar bundle and copy to current dist dir.'''

with temp_directory() as temp_dir:

name = splitext(basename(aar))[0]

jar_name = name + '.jar'

info("unpack {} aar".format(name))

debug(" from {}".format(aar))

debug(" to {}".format(temp_dir))

shprint(sh.unzip, '-o', aar, '-d', temp_dir)

jar_src = join(temp_dir, 'classes.jar')

jar_tgt = join('libs', jar_name)

debug("copy {} jar".format(name))

debug(" from {}".format(jar_src))

debug(" to {}".format(jar_tgt))

ensure_dir('libs')

shprint(sh.cp, '-a', jar_src, jar_tgt)

so_src_dir = join(temp_dir, 'jni', arch.arch)

so_tgt_dir = join('libs', arch.arch)

debug("copy {} .so".format(name))

debug(" from {}".format(so_src_dir))

debug(" to {}".format(so_tgt_dir))

ensure_dir(so_tgt_dir)

so_files = glob.glob(join(so_src_dir, '*.so'))

shprint(sh.cp, '-a', *so_files, so_tgt_dir)

def strip_libraries(self, arch):

info('Stripping libraries')

env = arch.get_env()

tokens = shlex.split(env['STRIP'])

strip = sh.Command(tokens[0])

if len(tokens) > 1:

strip = strip.bake(tokens[1:])

libs_dir = join(self.dist_dir, f'_python_bundle__{arch.arch}',

'_python_bundle', 'modules')

filens = shprint(sh.find, libs_dir, join(self.dist_dir, 'libs'),

'-iname', '*.so', _env=env).stdout.decode('utf-8')

logger.info('Stripping libraries in private dir')

for filen in filens.split('\n'):

if not filen:

continue # skip the last ''

try:

strip(filen, _env=env)

except sh.ErrorReturnCode_1:

logger.debug('Failed to strip ' + filen)

def fry_eggs(self, sitepackages):

info('Frying eggs in {}'.format(sitepackages))

for d in listdir(sitepackages):

rd = join(sitepackages, d)

if isdir(rd) and d.endswith('.egg'):

info(' ' + d)

files = [join(rd, f) for f in listdir(rd) if f != 'EGG-INFO']

for f in files:

move(f, sitepackages)

""" This function expands to lists of all different available

# Add in all the deps of recipes where there is no alternative:

recipes_with_deps = list(recipes)

for entry in recipes:

if not isinstance(entry, (tuple, list)) or len(entry) == 1:

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

entry = entry[0]

try:

recipe = Recipe.get_recipe(entry, ctx)

recipes_with_deps += recipe.depends

except ValueError:

# it's a pure python package without a recipe, so we

# don't know the dependencies...skipping for now

pass

# Split up lists by available alternatives:

recipe_lists = [[]]

for recipe in recipes_with_deps:

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

new_recipe_lists = []

for alternative in recipe:

for old_list in recipe_lists:

new_list = [i for i in old_list]

new_list.append(alternative)

new_recipe_lists.append(new_list)

recipe_lists = new_recipe_lists

else:

for existing_list in recipe_lists:

existing_list.append(recipe)