diff --git a/buildozer.spec.sample b/buildozer.spec.sample
index 7a39a4ea..538885bd 100644
--- a/buildozer.spec.sample
+++ b/buildozer.spec.sample
@@ -200,7 +200,7 @@ p4a.local_recipes = ~/Dev/Python/lbry-android/recipes
#p4a.hook =
# (str) Bootstrap to use for android builds
-# p4a.bootstrap = sdl2
+p4a.bootstrap = lbry
#
diff --git a/buildozer.spec.travis b/buildozer.spec.travis
index 0438546f..6efdb38f 100644
--- a/buildozer.spec.travis
+++ b/buildozer.spec.travis
@@ -200,7 +200,7 @@ p4a.local_recipes = ./recipes
#p4a.hook =
# (str) Bootstrap to use for android builds
-# p4a.bootstrap = sdl2
+p4a.bootstrap = lbry
#
diff --git a/p4a/pythonforandroid/bootstraps/lbry/__init__.py b/p4a/pythonforandroid/bootstraps/lbry/__init__.py
new file mode 100644
index 00000000..7cf3dd54
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/__init__.py
@@ -0,0 +1,123 @@
+from pythonforandroid.toolchain import Bootstrap, shprint, current_directory, info, warning, ArchARM, info_main
+from os.path import join, exists, curdir, abspath
+from os import walk
+import glob
+import sh
+
+class LbryBootstrap(Bootstrap):
+ name = 'lbry'
+
+ recipe_depends = ['sdl2', ('python2', 'python3crystax')]
+
+ def run_distribute(self):
+ info_main('# Creating Android project from build and {} bootstrap'.format(
+ self.name))
+
+ info('This currently just copies the SDL2 build stuff straight from the build dir.')
+ shprint(sh.rm, '-rf', 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))
+
+ arch = self.ctx.archs[0]
+ if len(self.ctx.archs) > 1:
+ raise ValueError('built for more than one arch, but bootstrap cannot handle that yet')
+ info('Bootstrap running with arch {}'.format(arch))
+
+ with current_directory(self.dist_dir):
+ info('Copying python distribution')
+
+ if not exists('private') and not self.ctx.python_recipe.from_crystax:
+ shprint(sh.mkdir, 'private')
+ if not exists('crystax_python') and self.ctx.python_recipe.from_crystax:
+ shprint(sh.mkdir, 'crystax_python')
+ shprint(sh.mkdir, 'crystax_python/crystax_python')
+ if not exists('assets'):
+ shprint(sh.mkdir, 'assets')
+
+ hostpython = sh.Command(self.ctx.hostpython)
+ if not self.ctx.python_recipe.from_crystax:
+ try:
+ shprint(hostpython, '-OO', '-m', 'compileall',
+ self.ctx.get_python_install_dir(),
+ _tail=10, _filterout="^Listing")
+ except sh.ErrorReturnCode:
+ pass
+ if not exists('python-install'):
+ shprint(sh.cp, '-a', self.ctx.get_python_install_dir(), './python-install')
+
+ self.distribute_libs(arch, [self.ctx.get_libs_dir(arch.arch)])
+ self.distribute_aars(arch)
+ self.distribute_javaclasses(self.ctx.javaclass_dir)
+
+ if not self.ctx.python_recipe.from_crystax:
+ info('Filling private directory')
+ if not exists(join('private', 'lib')):
+ info('private/lib does not exist, making')
+ shprint(sh.cp, '-a', join('python-install', 'lib'), 'private')
+ shprint(sh.mkdir, '-p', join('private', 'include', 'python2.7'))
+
+ # AND: Copylibs stuff should go here
+ if exists(join('libs', arch.arch, 'libpymodules.so')):
+ shprint(sh.mv, join('libs', arch.arch, 'libpymodules.so'), 'private/')
+ shprint(sh.cp, join('python-install', 'include' , 'python2.7', 'pyconfig.h'), join('private', 'include', 'python2.7/'))
+
+ info('Removing some unwanted files')
+ shprint(sh.rm, '-f', join('private', 'lib', 'libpython2.7.so'))
+ shprint(sh.rm, '-rf', join('private', 'lib', 'pkgconfig'))
+
+ libdir = join(self.dist_dir, 'private', 'lib', 'python2.7')
+ site_packages_dir = join(libdir, 'site-packages')
+ with current_directory(libdir):
+ # shprint(sh.xargs, 'rm', sh.grep('-E', '*\.(py|pyx|so\.o|so\.a|so\.libs)$', sh.find('.')))
+ removes = []
+ for dirname, something, filens in walk('.'):
+ for filename in filens:
+ for suffix in ('py', 'pyc', 'so.o', 'so.a', 'so.libs'):
+ if filename.endswith(suffix):
+ removes.append(filename)
+ shprint(sh.rm, '-f', *removes)
+
+ info('Deleting some other stuff not used on android')
+ # To quote the original distribute.sh, 'well...'
+ # shprint(sh.rm, '-rf', 'ctypes')
+ shprint(sh.rm, '-rf', 'lib2to3')
+ shprint(sh.rm, '-rf', 'idlelib')
+ for filename in glob.glob('config/libpython*.a'):
+ shprint(sh.rm, '-f', filename)
+ shprint(sh.rm, '-rf', 'config/python.o')
+ # shprint(sh.rm, '-rf', 'lib-dynload/_ctypes_test.so')
+ # shprint(sh.rm, '-rf', 'lib-dynload/_testcapi.so')
+
+ else: # Python *is* loaded from crystax
+ ndk_dir = self.ctx.ndk_dir
+ py_recipe = self.ctx.python_recipe
+ python_dir = join(ndk_dir, 'sources', 'python', py_recipe.version,
+ 'libs', arch.arch)
+
+ shprint(sh.cp, '-r', join(python_dir, 'stdlib.zip'), 'crystax_python/crystax_python')
+ shprint(sh.cp, '-r', join(python_dir, 'modules'), 'crystax_python/crystax_python')
+ shprint(sh.cp, '-r', self.ctx.get_python_install_dir(), 'crystax_python/crystax_python/site-packages')
+
+ info('Renaming .so files to reflect cross-compile')
+ site_packages_dir = 'crystax_python/crystax_python/site-packages'
+ filens = shprint(sh.find, site_packages_dir, '-iname', '*.so').stdout.decode(
+ 'utf-8').split('\n')[:-1]
+ for filen in filens:
+ parts = filen.split('.')
+ if len(parts) <= 2:
+ continue
+ shprint(sh.mv, filen, filen.split('.')[0] + '.so')
+ site_packages_dir = join(abspath(curdir),
+ site_packages_dir)
+ 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.strip_libraries(arch)
+ self.fry_eggs(site_packages_dir)
+ super(LbryBootstrap, self).run_distribute()
+
+bootstrap = LbryBootstrap()
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/ant.properties b/p4a/pythonforandroid/bootstraps/lbry/build/ant.properties
new file mode 100644
index 00000000..f74e644b
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/ant.properties
@@ -0,0 +1,18 @@
+# This file is used to override default values used by the Ant build system.
+#
+# This file must be checked into Version Control Systems, as it is
+# integral to the build system of your project.
+
+# This file is only used by the Ant script.
+
+# You can use this to override default values such as
+# 'source.dir' for the location of your java source folder and
+# 'out.dir' for the location of your output folder.
+
+# You can also use it define how the release builds are signed by declaring
+# the following properties:
+# 'key.store' for the location of your keystore and
+# 'key.alias' for the name of the key to use.
+# The password will be asked during the build when you use the 'release' target.
+
+source.absolute.dir = tmp-src
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/blacklist.txt b/p4a/pythonforandroid/bootstraps/lbry/build/blacklist.txt
new file mode 100644
index 00000000..3d596e44
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/blacklist.txt
@@ -0,0 +1,83 @@
+# prevent user to include invalid extensions
+*.apk
+*.pxd
+
+# eggs
+*.egg-info
+
+# unit test
+unittest/*
+
+# python config
+config/makesetup
+
+# unused kivy files (platform specific)
+kivy/input/providers/wm_*
+kivy/input/providers/mactouch*
+kivy/input/providers/probesysfs*
+kivy/input/providers/mtdev*
+kivy/input/providers/hidinput*
+kivy/core/camera/camera_videocapture*
+kivy/core/spelling/*osx*
+kivy/core/video/video_pyglet*
+kivy/tools
+kivy/tests/*
+kivy/*/*.h
+kivy/*/*.pxi
+
+# unused encodings
+lib-dynload/*codec*
+encodings/cp*.pyo
+encodings/tis*
+encodings/shift*
+encodings/bz2*
+encodings/iso*
+encodings/undefined*
+encodings/johab*
+encodings/p*
+encodings/m*
+encodings/euc*
+encodings/k*
+encodings/unicode_internal*
+encodings/quo*
+encodings/gb*
+encodings/big5*
+encodings/hp*
+encodings/hz*
+
+# unused python modules
+bsddb/*
+wsgiref/*
+hotshot/*
+pydoc_data/*
+tty.pyo
+anydbm.pyo
+nturl2path.pyo
+LICENCE.txt
+macurl2path.pyo
+dummy_threading.pyo
+audiodev.pyo
+antigravity.pyo
+dumbdbm.pyo
+sndhdr.pyo
+__phello__.foo.pyo
+sunaudio.pyo
+os2emxpath.pyo
+multiprocessing/dummy*
+
+# unused binaries python modules
+lib-dynload/termios.so
+lib-dynload/_lsprof.so
+lib-dynload/*audioop.so
+lib-dynload/mmap.so
+lib-dynload/_hotshot.so
+lib-dynload/_heapq.so
+lib-dynload/_json.so
+lib-dynload/grp.so
+lib-dynload/resource.so
+lib-dynload/pyexpat.so
+lib-dynload/_ctypes_test.so
+lib-dynload/_testcapi.so
+
+# odd files
+plat-linux3/regen
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/build.py b/p4a/pythonforandroid/bootstraps/lbry/build/build.py
new file mode 100755
index 00000000..b5dbbe28
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/build.py
@@ -0,0 +1,566 @@
+#!/usr/bin/env python2.7
+
+from __future__ import print_function
+
+from os.path import dirname, join, isfile, realpath, relpath, split, exists
+from os import makedirs, remove
+import os
+import tarfile
+import time
+import subprocess
+import shutil
+from zipfile import ZipFile
+import sys
+import re
+
+from fnmatch import fnmatch
+
+import jinja2
+
+if os.name == 'nt':
+ ANDROID = 'android.bat'
+ ANT = 'ant.bat'
+else:
+ ANDROID = 'android'
+ ANT = 'ant'
+
+curdir = dirname(__file__)
+
+# Try to find a host version of Python that matches our ARM version.
+PYTHON = join(curdir, 'python-install', 'bin', 'python.host')
+if not exists(PYTHON):
+ print('Could not find hostpython, will not compile to .pyo (this is normal with python3)')
+ PYTHON = None
+
+BLACKLIST_PATTERNS = [
+ # code versionning
+ '^*.hg/*',
+ '^*.git/*',
+ '^*.bzr/*',
+ '^*.svn/*',
+
+ # pyc/py
+ '*.pyc',
+
+ # temp files
+ '~',
+ '*.bak',
+ '*.swp',
+]
+if PYTHON is not None:
+ BLACKLIST_PATTERNS.append('*.py')
+
+WHITELIST_PATTERNS = ['pyconfig.h', ]
+
+python_files = []
+
+
+environment = jinja2.Environment(loader=jinja2.FileSystemLoader(
+ join(curdir, 'templates')))
+
+def render(template, dest, **kwargs):
+ '''Using jinja2, render `template` to the filename `dest`, supplying the
+
+ keyword arguments as template parameters.
+ '''
+
+ dest_dir = dirname(dest)
+ if dest_dir and not exists(dest_dir):
+ makedirs(dest_dir)
+
+ template = environment.get_template(template)
+ text = template.render(**kwargs)
+
+ f = open(dest, 'wb')
+ f.write(text.encode('utf-8'))
+ f.close()
+
+
+def is_whitelist(name):
+ return match_filename(WHITELIST_PATTERNS, name)
+
+
+def is_blacklist(name):
+ if is_whitelist(name):
+ return False
+ return match_filename(BLACKLIST_PATTERNS, name)
+
+
+def match_filename(pattern_list, name):
+ for pattern in pattern_list:
+ if pattern.startswith('^'):
+ pattern = pattern[1:]
+ else:
+ pattern = '*/' + pattern
+ if fnmatch(name, pattern):
+ return True
+
+
+def listfiles(d):
+ basedir = d
+ subdirlist = []
+ for item in os.listdir(d):
+ fn = join(d, item)
+ if isfile(fn):
+ yield fn
+ else:
+ subdirlist.append(join(basedir, item))
+ for subdir in subdirlist:
+ for fn in listfiles(subdir):
+ yield fn
+
+def make_python_zip():
+ '''
+ Search for all the python related files, and construct the pythonXX.zip
+ According to
+ # http://randomsplat.com/id5-cross-compiling-python-for-embedded-linux.html
+ site-packages, config and lib-dynload will be not included.
+ '''
+
+ if not exists('private'):
+ print('No compiled python is present to zip, skipping.')
+ print('this should only be the case if you are using the CrystaX python')
+ return
+
+ global python_files
+ d = realpath(join('private', 'lib', 'python2.7'))
+
+
+ def select(fn):
+ if is_blacklist(fn):
+ return False
+ fn = realpath(fn)
+ assert(fn.startswith(d))
+ fn = fn[len(d):]
+ if (fn.startswith('/site-packages/') or
+ fn.startswith('/config/') or
+ fn.startswith('/lib-dynload/') or
+ fn.startswith('/libpymodules.so')):
+ return False
+ return fn
+
+ # get a list of all python file
+ python_files = [x for x in listfiles(d) if select(x)]
+
+ # create the final zipfile
+ zfn = join('private', 'lib', 'python27.zip')
+ zf = ZipFile(zfn, 'w')
+
+ # put all the python files in it
+ for fn in python_files:
+ afn = fn[len(d):]
+ zf.write(fn, afn)
+ zf.close()
+
+def make_tar(tfn, source_dirs, ignore_path=[]):
+ '''
+ Make a zip file `fn` from the contents of source_dis.
+ '''
+
+ # selector function
+ def select(fn):
+ rfn = realpath(fn)
+ for p in ignore_path:
+ if p.endswith('/'):
+ p = p[:-1]
+ if rfn.startswith(p):
+ return False
+ if rfn in python_files:
+ return False
+ return not is_blacklist(fn)
+
+ # get the files and relpath file of all the directory we asked for
+ files = []
+ for sd in source_dirs:
+ sd = realpath(sd)
+ compile_dir(sd)
+ files += [(x, relpath(realpath(x), sd)) for x in listfiles(sd)
+ if select(x)]
+
+ # create tar.gz of thoses files
+ tf = tarfile.open(tfn, 'w:gz', format=tarfile.USTAR_FORMAT)
+ dirs = []
+ for fn, afn in files:
+# print('%s: %s' % (tfn, fn))
+ dn = dirname(afn)
+ if dn not in dirs:
+ # create every dirs first if not exist yet
+ d = ''
+ for component in split(dn):
+ d = join(d, component)
+ if d.startswith('/'):
+ d = d[1:]
+ if d == '' or d in dirs:
+ continue
+ dirs.append(d)
+ tinfo = tarfile.TarInfo(d)
+ tinfo.type = tarfile.DIRTYPE
+ tf.addfile(tinfo)
+
+ # put the file
+ tf.add(fn, afn)
+ tf.close()
+
+
+def compile_dir(dfn):
+ '''
+ Compile *.py in directory `dfn` to *.pyo
+ '''
+ # -OO = strip docstrings
+ if PYTHON is None:
+ return
+ subprocess.call([PYTHON, '-OO', '-m', 'compileall', '-f', dfn])
+
+
+def make_package(args):
+ # # Update the project to a recent version.
+ # try:
+ # subprocess.call([ANDROID, 'update', 'project', '-p', '.', '-t',
+ # 'android-{}'.format(args.sdk_version)])
+ # except (OSError, IOError):
+ # print('An error occured while calling', ANDROID, 'update')
+ # print('Your PATH must include android tools.')
+ # sys.exit(-1)
+
+ # Ignore warning if the launcher is in args
+ if not args.launcher:
+ if not (exists(join(realpath(args.private), 'main.py')) or
+ exists(join(realpath(args.private), 'main.pyo'))):
+ print('''BUILD FAILURE: No main.py(o) found in your app directory. This
+file must exist to act as the entry point for you app. If your app is
+started by a file with a different name, rename it to main.py or add a
+main.py that loads it.''')
+ exit(1)
+
+ # Delete the old assets.
+ if exists('assets/public.mp3'):
+ os.unlink('assets/public.mp3')
+
+ if exists('assets/private.mp3'):
+ os.unlink('assets/private.mp3')
+
+ # In order to speedup import and initial depack,
+ # construct a python27.zip
+ make_python_zip()
+
+ # Package up the private and public data.
+ # AND: Just private for now
+ tar_dirs = [args.private]
+ if exists('private'):
+ tar_dirs.append('private')
+ if exists('crystax_python'):
+ tar_dirs.append('crystax_python')
+
+ if args.private:
+ make_tar('assets/private.mp3', tar_dirs, args.ignore_path)
+ elif args.launcher:
+ # clean 'None's as a result of main.py path absence
+ tar_dirs = [tdir for tdir in tar_dirs if tdir]
+ make_tar('assets/private.mp3', tar_dirs, args.ignore_path)
+ # else:
+ # make_tar('assets/private.mp3', ['private'])
+
+ # if args.dir:
+ # make_tar('assets/public.mp3', [args.dir], args.ignore_path)
+
+
+ # # Build.
+ # try:
+ # for arg in args.command:
+ # subprocess.check_call([ANT, arg])
+ # except (OSError, IOError):
+ # print 'An error occured while calling', ANT
+ # print 'Did you install ant on your system ?'
+ # sys.exit(-1)
+
+
+ # folder name for launcher
+ url_scheme = 'kivy'
+
+ # Prepare some variables for templating process
+ if args.launcher:
+ default_icon = 'templates/launcher-icon.png'
+ default_presplash = 'templates/launcher-presplash.jpg'
+ else:
+ default_icon = 'templates/kivy-icon.png'
+ default_presplash = 'templates/kivy-presplash.jpg'
+ shutil.copy(args.icon or default_icon, 'res/drawable/icon.png')
+
+ shutil.copy(args.presplash or default_presplash,
+ 'res/drawable/presplash.jpg')
+
+ # If extra Java jars were requested, copy them into the libs directory
+ if args.add_jar:
+ for jarname in args.add_jar:
+ if not exists(jarname):
+ print('Requested jar does not exist: {}'.format(jarname))
+ sys.exit(-1)
+ shutil.copy(jarname, 'libs')
+
+ versioned_name = (args.name.replace(' ', '').replace('\'', '') +
+ '-' + args.version)
+
+ version_code = 0
+ if not args.numeric_version:
+ for i in args.version.split('.'):
+ version_code *= 100
+ version_code += int(i)
+ args.numeric_version = str(version_code)
+
+ if args.intent_filters:
+ with open(args.intent_filters) as fd:
+ args.intent_filters = fd.read()
+
+ if args.extra_source_dirs:
+ esd = []
+ for spec in args.extra_source_dirs:
+ if ':' in spec:
+ specdir, specincludes = spec.split(':')
+ else:
+ specdir = spec
+ specincludes = '**'
+ esd.append((realpath(specdir), specincludes))
+ args.extra_source_dirs = esd
+ else:
+ args.extra_source_dirs = []
+
+ service = False
+ if args.private:
+ service_main = join(realpath(args.private), 'service', 'main.py')
+ if exists(service_main) or exists(service_main + 'o'):
+ service = True
+
+ service_names = []
+ for sid, spec in enumerate(args.services):
+ spec = spec.split(':')
+ name = spec[0]
+ entrypoint = spec[1]
+ options = spec[2:]
+
+ foreground = 'foreground' in options
+ sticky = 'sticky' in options
+
+ service_names.append(name)
+ render(
+ 'Service.tmpl.java',
+ 'src/{}/Service{}.java'.format(args.package.replace(".", "/"), name.capitalize()),
+ name=name,
+ entrypoint=entrypoint,
+ args=args,
+ foreground=foreground,
+ sticky=sticky,
+ service_id=sid + 1,
+ )
+
+ render(
+ 'AndroidManifest.tmpl.xml',
+ 'AndroidManifest.xml',
+ args=args,
+ service=service,
+ service_names=service_names,
+ url_scheme=url_scheme,
+ )
+
+ render(
+ 'build.tmpl.xml',
+ 'build.xml',
+ args=args,
+ versioned_name=versioned_name)
+
+ render(
+ 'strings.tmpl.xml',
+ 'res/values/strings.xml',
+ args=args,
+ url_scheme=url_scheme,
+ )
+
+ # add colors.xml
+ render(
+ 'colors.tmpl.xml',
+ 'res/values/colors.xml',
+ args=args,
+ url_scheme=url_scheme,
+ )
+
+ # add activity_service_control
+ render(
+ 'activity_service_control.xml',
+ 'res/layout/activity_service_control.xml',
+ args=args,
+ url_scheme=url_scheme,
+ )
+
+ render(
+ 'custom_rules.tmpl.xml',
+ 'custom_rules.xml',
+ args=args)
+
+ if args.sign:
+ render('build.properties', 'build.properties')
+ else:
+ if exists('build.properties'):
+ os.remove('build.properties')
+
+ with open(join(dirname(__file__), 'res',
+ 'values', 'strings.xml')) as fileh:
+ lines = fileh.read()
+
+ with open(join(dirname(__file__), 'res',
+ 'values', 'strings.xml'), 'w') as fileh:
+ fileh.write(re.sub(r'"private_version">[0-9\.]*<',
+ '"private_version">{}<'.format(
+ str(time.time())), lines))
+
+
+def parse_args(args=None):
+ global BLACKLIST_PATTERNS, WHITELIST_PATTERNS, PYTHON
+ default_android_api = 12
+ import argparse
+ ap = argparse.ArgumentParser(description='''\
+Package a Python application for Android.
+
+For this to work, Java and Ant need to be in your path, as does the
+tools directory of the Android SDK.
+''')
+
+ ap.add_argument('--private', dest='private',
+ help='the dir of user files')
+ # , required=True) for launcher, crashes in make_package
+ # if not mentioned (and the check is there anyway)
+ ap.add_argument('--package', dest='package',
+ help=('The name of the java package the project will be'
+ ' packaged under.'),
+ required=True)
+ ap.add_argument('--name', dest='name',
+ help=('The human-readable name of the project.'),
+ required=True)
+ ap.add_argument('--numeric-version', dest='numeric_version',
+ help=('The numeric version number of the project. If not '
+ 'given, this is automatically computed from the '
+ 'version.'))
+ ap.add_argument('--version', dest='version',
+ help=('The version number of the project. This should '
+ 'consist of numbers and dots, and should have the '
+ 'same number of groups of numbers as previous '
+ 'versions.'),
+ required=True)
+ ap.add_argument('--orientation', dest='orientation', default='portrait',
+ help=('The orientation that the game will display in. '
+ 'Usually one of "landscape", "portrait", '
+ '"sensor", or "user" (the same as "sensor" but '
+ 'obeying the user\'s Android rotation setting). '
+ 'The full list of options is given under '
+ 'android_screenOrientation at '
+ 'https://developer.android.com/guide/topics/manifest/'
+ 'activity-element.html'))
+ ap.add_argument('--launcher', dest='launcher', action='store_true',
+ help=('Provide this argument to build a multi-app '
+ 'launcher, rather than a single app.'))
+ ap.add_argument('--icon', dest='icon',
+ help='A png file to use as the icon for the application.')
+ ap.add_argument('--permission', dest='permissions', action='append',
+ help='The permissions to give this app.', nargs='+')
+ ap.add_argument('--meta-data', dest='meta_data', action='append',
+ help='Custom key=value to add in application metadata')
+ ap.add_argument('--presplash', dest='presplash',
+ help=('A jpeg file to use as a screen while the '
+ 'application is loading.'))
+ ap.add_argument('--presplash-color', dest='presplash_color', default='#000000',
+ help=('A string to set the loading screen background color. '
+ 'Supported formats are: #RRGGBB #AARRGGBB or color names '
+ 'like red, green, blue, etc.'))
+ ap.add_argument('--wakelock', dest='wakelock', action='store_true',
+ help=('Indicate if the application needs the device '
+ 'to stay on'))
+ ap.add_argument('--window', dest='window', action='store_true',
+ help='Indicate if the application will be windowed')
+ ap.add_argument('--blacklist', dest='blacklist',
+ default=join(curdir, 'blacklist.txt'),
+ help=('Use a blacklist file to match unwanted file in '
+ 'the final APK'))
+ ap.add_argument('--whitelist', dest='whitelist',
+ default=join(curdir, 'whitelist.txt'),
+ help=('Use a whitelist file to prevent blacklisting of '
+ 'file in the final APK'))
+ ap.add_argument('--add-jar', dest='add_jar', action='append',
+ help=('Add a Java .jar to the libs, so you can access its '
+ 'classes with pyjnius. You can specify this '
+ 'argument more than once to include multiple jars'))
+ ap.add_argument('--sdk', dest='sdk_version', default=-1,
+ type=int, help=('Android SDK version to use. Default to '
+ 'the value of minsdk'))
+ ap.add_argument('--minsdk', dest='min_sdk_version',
+ default=default_android_api, type=int,
+ help=('Minimum Android SDK version to use. Default to '
+ 'the value of ANDROIDAPI, or {} if not set'
+ .format(default_android_api)))
+ ap.add_argument('--intent-filters', dest='intent_filters',
+ help=('Add intent-filters xml rules to the '
+ 'AndroidManifest.xml file. The argument is a '
+ 'filename containing xml. The filename should be '
+ 'located relative to the python-for-android '
+ 'directory'))
+ ap.add_argument('--with-billing', dest='billing_pubkey',
+ help='If set, the billing service will be added (not implemented)')
+ ap.add_argument('--service', dest='services', action='append',
+ help='Declare a new service entrypoint: '
+ 'NAME:PATH_TO_PY[:foreground]')
+ ap.add_argument('--add-source', dest='extra_source_dirs', action='append',
+ help='Include additional source dirs in Java build')
+ ap.add_argument('--no-compile-pyo', dest='no_compile_pyo', action='store_true',
+ help='Do not optimise .py files to .pyo.')
+ ap.add_argument('--sign', action='store_true',
+ help=('Try to sign the APK with your credentials. You must set '
+ 'the appropriate environment variables.'))
+
+ if args is None:
+ args = sys.argv[1:]
+ args = ap.parse_args(args)
+ args.ignore_path = []
+
+ if args.name and args.name[0] == '"' and args.name[-1] == '"':
+ args.name = args.name[1:-1]
+
+ if args.billing_pubkey:
+ print('Billing not yet supported in sdl2 bootstrap!')
+ exit(1)
+
+ if args.sdk_version == -1:
+ args.sdk_version = args.min_sdk_version
+
+ if args.permissions is None:
+ args.permissions = []
+ elif args.permissions:
+ if isinstance(args.permissions[0], list):
+ args.permissions = [p for perm in args.permissions for p in perm]
+
+ if args.meta_data is None:
+ args.meta_data = []
+
+ if args.services is None:
+ args.services = []
+
+ if args.no_compile_pyo:
+ PYTHON = None
+ BLACKLIST_PATTERNS.remove('*.py')
+
+ if args.blacklist:
+ with open(args.blacklist) as fd:
+ patterns = [x.strip() for x in fd.read().splitlines()
+ if x.strip() and not x.strip().startswith('#')]
+ BLACKLIST_PATTERNS += patterns
+
+ if args.whitelist:
+ with open(args.whitelist) as fd:
+ patterns = [x.strip() for x in fd.read().splitlines()
+ if x.strip() and not x.strip().startswith('#')]
+ WHITELIST_PATTERNS += patterns
+
+ make_package(args)
+
+ return args
+
+
+if __name__ == "__main__":
+
+ parse_args()
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/build.xml b/p4a/pythonforandroid/bootstraps/lbry/build/build.xml
new file mode 100644
index 00000000..9f19a077
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/build.xml
@@ -0,0 +1,93 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/jni/Android.mk b/p4a/pythonforandroid/bootstraps/lbry/build/jni/Android.mk
new file mode 100644
index 00000000..5053e7d6
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/jni/Android.mk
@@ -0,0 +1 @@
+include $(call all-subdir-makefiles)
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/jni/Application.mk b/p4a/pythonforandroid/bootstraps/lbry/build/jni/Application.mk
new file mode 100644
index 00000000..e79e378f
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/jni/Application.mk
@@ -0,0 +1,7 @@
+
+# Uncomment this if you're using STL in your project
+# See CPLUSPLUS-SUPPORT.html in the NDK documentation for more information
+# APP_STL := stlport_static
+
+# APP_ABI := armeabi armeabi-v7a x86
+APP_ABI := $(ARCH)
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android.mk b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android.mk
new file mode 100644
index 00000000..41d689d6
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android.mk
@@ -0,0 +1,27 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := main
+
+SDL_PATH := ../SDL
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(SDL_PATH)/include
+
+# Add your application source files here...
+LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.c \
+ start.c
+
+LOCAL_CFLAGS += -I$(LOCAL_PATH)/../../../../other_builds/$(PYTHON2_NAME)/$(ARCH)/python2/python-install/include/python2.7 $(EXTRA_CFLAGS)
+
+LOCAL_SHARED_LIBRARIES := SDL2 python_shared
+
+LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog $(EXTRA_LDLIBS)
+
+LOCAL_LDFLAGS += -L$(LOCAL_PATH)/../../../../other_builds/$(PYTHON2_NAME)/$(ARCH)/python2/python-install/lib $(APPLICATION_ADDITIONAL_LDFLAGS)
+
+include $(BUILD_SHARED_LIBRARY)
+
+ifdef CRYSTAX_PYTHON_VERSION
+ $(call import-module,python/$(CRYSTAX_PYTHON_VERSION))
+endif
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android_static.mk b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android_static.mk
new file mode 100644
index 00000000..faed669c
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/Android_static.mk
@@ -0,0 +1,12 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := main
+
+LOCAL_SRC_FILES := YourSourceHere.c
+
+LOCAL_STATIC_LIBRARIES := SDL2_static
+
+include $(BUILD_SHARED_LIBRARY)
+$(call import-module,SDL)LOCAL_PATH := $(call my-dir)
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/start.c b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/start.c
new file mode 100644
index 00000000..7582348c
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/jni/src/start.c
@@ -0,0 +1,320 @@
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+#error Python headers needed to compile C extensions, please install development version of Python.
+#else
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "SDL.h"
+#include "android/log.h"
+#include "SDL_opengles2.h"
+
+#define ENTRYPOINT_MAXLEN 128
+#define LOG(n, x) __android_log_write(ANDROID_LOG_INFO, (n), (x))
+#define LOGP(x) LOG("python", (x))
+
+static PyObject *androidembed_log(PyObject *self, PyObject *args) {
+ char *logstr = NULL;
+ if (!PyArg_ParseTuple(args, "s", &logstr)) {
+ return NULL;
+ }
+ LOG(getenv("PYTHON_NAME"), logstr);
+ Py_RETURN_NONE;
+}
+
+static PyMethodDef AndroidEmbedMethods[] = {
+ {"log", androidembed_log, METH_VARARGS, "Log on android platform"},
+ {NULL, NULL, 0, NULL}};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef androidembed = {PyModuleDef_HEAD_INIT, "androidembed",
+ "", -1, AndroidEmbedMethods};
+
+PyMODINIT_FUNC initandroidembed(void) {
+ return PyModule_Create(&androidembed);
+}
+#else
+PyMODINIT_FUNC initandroidembed(void) {
+ (void)Py_InitModule("androidembed", AndroidEmbedMethods);
+}
+#endif
+
+int dir_exists(char *filename) {
+ struct stat st;
+ if (stat(filename, &st) == 0) {
+ if (S_ISDIR(st.st_mode))
+ return 1;
+ }
+ return 0;
+}
+
+int file_exists(const char *filename) {
+ FILE *file;
+ if (file = fopen(filename, "r")) {
+ fclose(file);
+ return 1;
+ }
+ return 0;
+}
+
+/* int main(int argc, char **argv) { */
+int main(int argc, char *argv[]) {
+
+ char *env_argument = NULL;
+ char *env_entrypoint = NULL;
+ char *env_logname = NULL;
+ char entrypoint[ENTRYPOINT_MAXLEN];
+ int ret = 0;
+ FILE *fd;
+
+ /* AND: Several filepaths are hardcoded here, these must be made
+ configurable */
+ /* AND: P4A uses env vars...not sure what's best */
+ LOGP("Initialize Python for Android");
+ env_argument = getenv("ANDROID_ARGUMENT");
+ setenv("ANDROID_APP_PATH", env_argument, 1);
+ env_entrypoint = getenv("ANDROID_ENTRYPOINT");
+ env_logname = getenv("PYTHON_NAME");
+
+ if (env_logname == NULL) {
+ env_logname = "python";
+ setenv("PYTHON_NAME", "python", 1);
+ }
+
+ LOGP("Changing directory to the one provided by ANDROID_ARGUMENT");
+ LOGP(env_argument);
+ chdir(env_argument);
+
+ Py_SetProgramName(L"android_python");
+
+#if PY_MAJOR_VERSION >= 3
+ /* our logging module for android
+ */
+ PyImport_AppendInittab("androidembed", initandroidembed);
+#endif
+
+ LOGP("Preparing to initialize python");
+
+ if (dir_exists("crystax_python/")) {
+ LOGP("crystax_python exists");
+ char paths[256];
+ snprintf(paths, 256,
+ "%s/crystax_python/stdlib.zip:%s/crystax_python/modules",
+ env_argument, env_argument);
+ /* snprintf(paths, 256, "%s/stdlib.zip:%s/modules", env_argument,
+ * env_argument); */
+ LOGP("calculated paths to be...");
+ LOGP(paths);
+
+#if PY_MAJOR_VERSION >= 3
+ wchar_t *wchar_paths = Py_DecodeLocale(paths, NULL);
+ Py_SetPath(wchar_paths);
+#else
+ char *wchar_paths = paths;
+ LOGP("Can't Py_SetPath in python2, so crystax python2 doesn't work yet");
+ exit(1);
+#endif
+
+ LOGP("set wchar paths...");
+ } else {
+ LOGP("crystax_python does not exist");
+ }
+
+ Py_Initialize();
+
+#if PY_MAJOR_VERSION < 3
+ PySys_SetArgv(argc, argv);
+#endif
+
+ LOGP("Initialized python");
+
+ /* ensure threads will work.
+ */
+ LOGP("AND: Init threads");
+ PyEval_InitThreads();
+
+#if PY_MAJOR_VERSION < 3
+ initandroidembed();
+#endif
+
+ PyRun_SimpleString("import androidembed\nandroidembed.log('testing python "
+ "print redirection')");
+
+ /* inject our bootstrap code to redirect python stdin/stdout
+ * replace sys.path with our path
+ */
+ PyRun_SimpleString("import sys, posix\n");
+ if (dir_exists("lib")) {
+ /* If we built our own python, set up the paths correctly */
+ LOGP("Setting up python from ANDROID_PRIVATE");
+ PyRun_SimpleString("private = posix.environ['ANDROID_APP_PATH']\n"
+ "argument = posix.environ['ANDROID_ARGUMENT']\n"
+ "sys.path[:] = [ \n"
+ " private + '/lib/python27.zip', \n"
+ " private + '/lib/python2.7/', \n"
+ " private + '/lib/python2.7/lib-dynload/', \n"
+ " private + '/lib/python2.7/site-packages/', \n"
+ " argument ]\n");
+ }
+
+ if (dir_exists("crystax_python")) {
+ char add_site_packages_dir[256];
+ snprintf(add_site_packages_dir, 256,
+ "sys.path.append('%s/crystax_python/site-packages')",
+ env_argument);
+
+ PyRun_SimpleString("import sys\n"
+ "sys.argv = ['notaninterpreterreally']\n"
+ "from os.path import realpath, join, dirname");
+ PyRun_SimpleString(add_site_packages_dir);
+ /* "sys.path.append(join(dirname(realpath(__file__)), 'site-packages'))") */
+ PyRun_SimpleString("sys.path = ['.'] + sys.path");
+ }
+
+ PyRun_SimpleString(
+ "class LogFile(object):\n"
+ " def __init__(self):\n"
+ " self.buffer = ''\n"
+ " def write(self, s):\n"
+ " s = self.buffer + s\n"
+ " lines = s.split(\"\\n\")\n"
+ " for l in lines[:-1]:\n"
+ " androidembed.log(l)\n"
+ " self.buffer = lines[-1]\n"
+ " def flush(self):\n"
+ " return\n"
+ "sys.stdout = sys.stderr = LogFile()\n"
+ "print('Android path', sys.path)\n"
+ "import os\n"
+ "print('os.environ is', os.environ)\n"
+ "print('Android kivy bootstrap done. __name__ is', __name__)");
+
+#if PY_MAJOR_VERSION < 3
+ PyRun_SimpleString("import site; print site.getsitepackages()\n");
+#endif
+
+ LOGP("AND: Ran string");
+
+ /* run it !
+ */
+ LOGP("Run user program, change dir and execute entrypoint");
+
+ /* Get the entrypoint, search the .pyo then .py
+ */
+ char *dot = strrchr(env_entrypoint, '.');
+ if (dot <= 0) {
+ LOGP("Invalid entrypoint, abort.");
+ return -1;
+ }
+ if (strlen(env_entrypoint) > ENTRYPOINT_MAXLEN - 2) {
+ LOGP("Entrypoint path is too long, try increasing ENTRYPOINT_MAXLEN.");
+ return -1;
+ }
+ if (!strcmp(dot, ".pyo")) {
+ if (!file_exists(env_entrypoint)) {
+ /* fallback on .py */
+ strcpy(entrypoint, env_entrypoint);
+ entrypoint[strlen(env_entrypoint) - 1] = '\0';
+ LOGP(entrypoint);
+ if (!file_exists(entrypoint)) {
+ LOGP("Entrypoint not found (.pyo, fallback on .py), abort");
+ return -1;
+ }
+ } else {
+ strcpy(entrypoint, env_entrypoint);
+ }
+ } else if (!strcmp(dot, ".py")) {
+ /* if .py is passed, check the pyo version first */
+ strcpy(entrypoint, env_entrypoint);
+ entrypoint[strlen(env_entrypoint) + 1] = '\0';
+ entrypoint[strlen(env_entrypoint)] = 'o';
+ if (!file_exists(entrypoint)) {
+ /* fallback on pure python version */
+ if (!file_exists(env_entrypoint)) {
+ LOGP("Entrypoint not found (.py), abort.");
+ return -1;
+ }
+ strcpy(entrypoint, env_entrypoint);
+ }
+ } else {
+ LOGP("Entrypoint have an invalid extension (must be .py or .pyo), abort.");
+ return -1;
+ }
+ // LOGP("Entrypoint is:");
+ // LOGP(entrypoint);
+ fd = fopen(entrypoint, "r");
+ if (fd == NULL) {
+ LOGP("Open the entrypoint failed");
+ LOGP(entrypoint);
+ return -1;
+ }
+
+ /* run python !
+ */
+ ret = PyRun_SimpleFile(fd, entrypoint);
+
+ if (PyErr_Occurred() != NULL) {
+ ret = 1;
+ PyErr_Print(); /* This exits with the right code if SystemExit. */
+ PyObject *f = PySys_GetObject("stdout");
+ if (PyFile_WriteString(
+ "\n", f)) /* python2 used Py_FlushLine, but this no longer exists */
+ PyErr_Clear();
+ }
+
+ /* close everything
+ */
+ Py_Finalize();
+ fclose(fd);
+
+ LOGP("Python for android ended.");
+ return ret;
+}
+
+JNIEXPORT void JNICALL Java_org_kivy_android_PythonService_nativeStart(
+ JNIEnv *env, jobject thiz, jstring j_android_private,
+ jstring j_android_argument, jstring j_service_entrypoint,
+ jstring j_python_name, jstring j_python_home, jstring j_python_path,
+ jstring j_arg) {
+ jboolean iscopy;
+ const char *android_private =
+ (*env)->GetStringUTFChars(env, j_android_private, &iscopy);
+ const char *android_argument =
+ (*env)->GetStringUTFChars(env, j_android_argument, &iscopy);
+ const char *service_entrypoint =
+ (*env)->GetStringUTFChars(env, j_service_entrypoint, &iscopy);
+ const char *python_name =
+ (*env)->GetStringUTFChars(env, j_python_name, &iscopy);
+ const char *python_home =
+ (*env)->GetStringUTFChars(env, j_python_home, &iscopy);
+ const char *python_path =
+ (*env)->GetStringUTFChars(env, j_python_path, &iscopy);
+ const char *arg = (*env)->GetStringUTFChars(env, j_arg, &iscopy);
+
+ setenv("ANDROID_PRIVATE", android_private, 1);
+ setenv("ANDROID_ARGUMENT", android_argument, 1);
+ setenv("ANDROID_APP_PATH", android_argument, 1);
+ setenv("ANDROID_ENTRYPOINT", service_entrypoint, 1);
+ setenv("PYTHONOPTIMIZE", "2", 1);
+ setenv("PYTHON_NAME", python_name, 1);
+ setenv("PYTHONHOME", python_home, 1);
+ setenv("PYTHONPATH", python_path, 1);
+ setenv("PYTHON_SERVICE_ARGUMENT", arg, 1);
+
+ char *argv[] = {"."};
+ /* ANDROID_ARGUMENT points to service subdir,
+ * so main() will run main.py from this dir
+ */
+ main(1, argv);
+}
+
+#endif
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/proguard-project.txt b/p4a/pythonforandroid/bootstraps/lbry/build/proguard-project.txt
new file mode 100644
index 00000000..f2fe1559
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/proguard-project.txt
@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-hdpi/ic_launcher.png b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 00000000..d50bdaae
Binary files /dev/null and b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-hdpi/ic_launcher.png differ
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-mdpi/ic_launcher.png b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 00000000..0a299eb3
Binary files /dev/null and b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-mdpi/ic_launcher.png differ
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xhdpi/ic_launcher.png b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..a336ad5c
Binary files /dev/null and b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xhdpi/ic_launcher.png differ
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xxhdpi/ic_launcher.png b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..d423dac2
Binary files /dev/null and b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable-xxhdpi/ic_launcher.png differ
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable/.gitkeep b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable/icon.png b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable/icon.png
new file mode 100644
index 00000000..59a00ba6
Binary files /dev/null and b/p4a/pythonforandroid/bootstraps/lbry/build/res/drawable/icon.png differ
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/chooser_item.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/chooser_item.xml
new file mode 100644
index 00000000..1823b132
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/chooser_item.xml
@@ -0,0 +1,39 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/main.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/main.xml
new file mode 100644
index 00000000..123c4b6e
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/main.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_chooser.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_chooser.xml
new file mode 100644
index 00000000..23828e64
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_chooser.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_empty.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_empty.xml
new file mode 100644
index 00000000..ee548142
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/layout/project_empty.xml
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/values/colors.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/values/colors.xml
new file mode 100644
index 00000000..6876df8f
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/values/colors.xml
@@ -0,0 +1,9 @@
+
+
+ #3F51B5
+ #303F9F
+ #FF4081
+
+ #FF0000
+ #00C000
+
\ No newline at end of file
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/res/values/strings.xml b/p4a/pythonforandroid/bootstraps/lbry/build/res/values/strings.xml
new file mode 100644
index 00000000..eed34f3d
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/res/values/strings.xml
@@ -0,0 +1,10 @@
+
+ LbryControl
+ 0.1
+
+ Running
+ Service Status
+ Stopped
+ START
+ STOP
+
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/Octal.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/Octal.java
new file mode 100755
index 00000000..dd10624e
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/Octal.java
@@ -0,0 +1,141 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+/**
+ * @author Kamran Zafar
+ *
+ */
+public class Octal {
+
+ /**
+ * Parse an octal string from a header buffer. This is used for the file
+ * permission mode value.
+ *
+ * @param header
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ *
+ * @return The long value of the octal string.
+ */
+ public static long parseOctal(byte[] header, int offset, int length) {
+ long result = 0;
+ boolean stillPadding = true;
+
+ int end = offset + length;
+ for (int i = offset; i < end; ++i) {
+ if (header[i] == 0)
+ break;
+
+ if (header[i] == (byte) ' ' || header[i] == '0') {
+ if (stillPadding)
+ continue;
+
+ if (header[i] == (byte) ' ')
+ break;
+ }
+
+ stillPadding = false;
+
+ result = ( result << 3 ) + ( header[i] - '0' );
+ }
+
+ return result;
+ }
+
+ /**
+ * Parse an octal integer from a header buffer.
+ *
+ * @param value
+ * @param buf
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ *
+ * @return The integer value of the octal bytes.
+ */
+ public static int getOctalBytes(long value, byte[] buf, int offset, int length) {
+ int idx = length - 1;
+
+ buf[offset + idx] = 0;
+ --idx;
+ buf[offset + idx] = (byte) ' ';
+ --idx;
+
+ if (value == 0) {
+ buf[offset + idx] = (byte) '0';
+ --idx;
+ } else {
+ for (long val = value; idx >= 0 && val > 0; --idx) {
+ buf[offset + idx] = (byte) ( (byte) '0' + (byte) ( val & 7 ) );
+ val = val >> 3;
+ }
+ }
+
+ for (; idx >= 0; --idx) {
+ buf[offset + idx] = (byte) ' ';
+ }
+
+ return offset + length;
+ }
+
+ /**
+ * Parse the checksum octal integer from a header buffer.
+ *
+ * @param value
+ * @param buf
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ * @return The integer value of the entry's checksum.
+ */
+ public static int getCheckSumOctalBytes(long value, byte[] buf, int offset, int length) {
+ getOctalBytes( value, buf, offset, length );
+ buf[offset + length - 1] = (byte) ' ';
+ buf[offset + length - 2] = 0;
+ return offset + length;
+ }
+
+ /**
+ * Parse an octal long integer from a header buffer.
+ *
+ * @param value
+ * @param buf
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ *
+ * @return The long value of the octal bytes.
+ */
+ public static int getLongOctalBytes(long value, byte[] buf, int offset, int length) {
+ byte[] temp = new byte[length + 1];
+ getOctalBytes( value, temp, 0, length + 1 );
+ System.arraycopy( temp, 0, buf, offset, length );
+ return offset + length;
+ }
+
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarConstants.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarConstants.java
new file mode 100755
index 00000000..4611e20e
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarConstants.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+/**
+ * @author Kamran Zafar
+ *
+ */
+public class TarConstants {
+ public static final int EOF_BLOCK = 1024;
+ public static final int DATA_BLOCK = 512;
+ public static final int HEADER_BLOCK = 512;
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarEntry.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarEntry.java
new file mode 100755
index 00000000..fe01db46
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarEntry.java
@@ -0,0 +1,284 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+import java.io.File;
+import java.util.Date;
+
+/**
+ * @author Kamran Zafar
+ *
+ */
+public class TarEntry {
+ protected File file;
+ protected TarHeader header;
+
+ private TarEntry() {
+ this.file = null;
+ header = new TarHeader();
+ }
+
+ public TarEntry(File file, String entryName) {
+ this();
+ this.file = file;
+ this.extractTarHeader(entryName);
+ }
+
+ public TarEntry(byte[] headerBuf) {
+ this();
+ this.parseTarHeader(headerBuf);
+ }
+
+ /**
+ * Constructor to create an entry from an existing TarHeader object.
+ *
+ * This method is useful to add new entries programmatically (e.g. for
+ * adding files or directories that do not exist in the file system).
+ *
+ * @param header
+ *
+ */
+ public TarEntry(TarHeader header) {
+ this.file = null;
+ this.header = header;
+ }
+
+ public boolean equals(TarEntry it) {
+ return header.name.toString().equals(it.header.name.toString());
+ }
+
+ public boolean isDescendent(TarEntry desc) {
+ return desc.header.name.toString().startsWith(header.name.toString());
+ }
+
+ public TarHeader getHeader() {
+ return header;
+ }
+
+ public String getName() {
+ String name = header.name.toString();
+ if (header.namePrefix != null && !header.namePrefix.toString().equals("")) {
+ name = header.namePrefix.toString() + "/" + name;
+ }
+
+ return name;
+ }
+
+ public void setName(String name) {
+ header.name = new StringBuffer(name);
+ }
+
+ public int getUserId() {
+ return header.userId;
+ }
+
+ public void setUserId(int userId) {
+ header.userId = userId;
+ }
+
+ public int getGroupId() {
+ return header.groupId;
+ }
+
+ public void setGroupId(int groupId) {
+ header.groupId = groupId;
+ }
+
+ public String getUserName() {
+ return header.userName.toString();
+ }
+
+ public void setUserName(String userName) {
+ header.userName = new StringBuffer(userName);
+ }
+
+ public String getGroupName() {
+ return header.groupName.toString();
+ }
+
+ public void setGroupName(String groupName) {
+ header.groupName = new StringBuffer(groupName);
+ }
+
+ public void setIds(int userId, int groupId) {
+ this.setUserId(userId);
+ this.setGroupId(groupId);
+ }
+
+ public void setModTime(long time) {
+ header.modTime = time / 1000;
+ }
+
+ public void setModTime(Date time) {
+ header.modTime = time.getTime() / 1000;
+ }
+
+ public Date getModTime() {
+ return new Date(header.modTime * 1000);
+ }
+
+ public File getFile() {
+ return this.file;
+ }
+
+ public long getSize() {
+ return header.size;
+ }
+
+ public void setSize(long size) {
+ header.size = size;
+ }
+
+ /**
+ * Checks if the org.kamrazafar.jtar entry is a directory
+ *
+ * @return
+ */
+ public boolean isDirectory() {
+ if (this.file != null)
+ return this.file.isDirectory();
+
+ if (header != null) {
+ if (header.linkFlag == TarHeader.LF_DIR)
+ return true;
+
+ if (header.name.toString().endsWith("/"))
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Extract header from File
+ *
+ * @param entryName
+ */
+ public void extractTarHeader(String entryName) {
+ header = TarHeader.createHeader(entryName, file.length(), file.lastModified() / 1000, file.isDirectory());
+ }
+
+ /**
+ * Calculate checksum
+ *
+ * @param buf
+ * @return
+ */
+ public long computeCheckSum(byte[] buf) {
+ long sum = 0;
+
+ for (int i = 0; i < buf.length; ++i) {
+ sum += 255 & buf[i];
+ }
+
+ return sum;
+ }
+
+ /**
+ * Writes the header to the byte buffer
+ *
+ * @param outbuf
+ */
+ public void writeEntryHeader(byte[] outbuf) {
+ int offset = 0;
+
+ offset = TarHeader.getNameBytes(header.name, outbuf, offset, TarHeader.NAMELEN);
+ offset = Octal.getOctalBytes(header.mode, outbuf, offset, TarHeader.MODELEN);
+ offset = Octal.getOctalBytes(header.userId, outbuf, offset, TarHeader.UIDLEN);
+ offset = Octal.getOctalBytes(header.groupId, outbuf, offset, TarHeader.GIDLEN);
+
+ long size = header.size;
+
+ offset = Octal.getLongOctalBytes(size, outbuf, offset, TarHeader.SIZELEN);
+ offset = Octal.getLongOctalBytes(header.modTime, outbuf, offset, TarHeader.MODTIMELEN);
+
+ int csOffset = offset;
+ for (int c = 0; c < TarHeader.CHKSUMLEN; ++c)
+ outbuf[offset++] = (byte) ' ';
+
+ outbuf[offset++] = header.linkFlag;
+
+ offset = TarHeader.getNameBytes(header.linkName, outbuf, offset, TarHeader.NAMELEN);
+ offset = TarHeader.getNameBytes(header.magic, outbuf, offset, TarHeader.USTAR_MAGICLEN);
+ offset = TarHeader.getNameBytes(header.userName, outbuf, offset, TarHeader.USTAR_USER_NAMELEN);
+ offset = TarHeader.getNameBytes(header.groupName, outbuf, offset, TarHeader.USTAR_GROUP_NAMELEN);
+ offset = Octal.getOctalBytes(header.devMajor, outbuf, offset, TarHeader.USTAR_DEVLEN);
+ offset = Octal.getOctalBytes(header.devMinor, outbuf, offset, TarHeader.USTAR_DEVLEN);
+ offset = TarHeader.getNameBytes(header.namePrefix, outbuf, offset, TarHeader.USTAR_FILENAME_PREFIX);
+
+ for (; offset < outbuf.length;)
+ outbuf[offset++] = 0;
+
+ long checkSum = this.computeCheckSum(outbuf);
+
+ Octal.getCheckSumOctalBytes(checkSum, outbuf, csOffset, TarHeader.CHKSUMLEN);
+ }
+
+ /**
+ * Parses the tar header to the byte buffer
+ *
+ * @param header
+ * @param bh
+ */
+ public void parseTarHeader(byte[] bh) {
+ int offset = 0;
+
+ header.name = TarHeader.parseName(bh, offset, TarHeader.NAMELEN);
+ offset += TarHeader.NAMELEN;
+
+ header.mode = (int) Octal.parseOctal(bh, offset, TarHeader.MODELEN);
+ offset += TarHeader.MODELEN;
+
+ header.userId = (int) Octal.parseOctal(bh, offset, TarHeader.UIDLEN);
+ offset += TarHeader.UIDLEN;
+
+ header.groupId = (int) Octal.parseOctal(bh, offset, TarHeader.GIDLEN);
+ offset += TarHeader.GIDLEN;
+
+ header.size = Octal.parseOctal(bh, offset, TarHeader.SIZELEN);
+ offset += TarHeader.SIZELEN;
+
+ header.modTime = Octal.parseOctal(bh, offset, TarHeader.MODTIMELEN);
+ offset += TarHeader.MODTIMELEN;
+
+ header.checkSum = (int) Octal.parseOctal(bh, offset, TarHeader.CHKSUMLEN);
+ offset += TarHeader.CHKSUMLEN;
+
+ header.linkFlag = bh[offset++];
+
+ header.linkName = TarHeader.parseName(bh, offset, TarHeader.NAMELEN);
+ offset += TarHeader.NAMELEN;
+
+ header.magic = TarHeader.parseName(bh, offset, TarHeader.USTAR_MAGICLEN);
+ offset += TarHeader.USTAR_MAGICLEN;
+
+ header.userName = TarHeader.parseName(bh, offset, TarHeader.USTAR_USER_NAMELEN);
+ offset += TarHeader.USTAR_USER_NAMELEN;
+
+ header.groupName = TarHeader.parseName(bh, offset, TarHeader.USTAR_GROUP_NAMELEN);
+ offset += TarHeader.USTAR_GROUP_NAMELEN;
+
+ header.devMajor = (int) Octal.parseOctal(bh, offset, TarHeader.USTAR_DEVLEN);
+ offset += TarHeader.USTAR_DEVLEN;
+
+ header.devMinor = (int) Octal.parseOctal(bh, offset, TarHeader.USTAR_DEVLEN);
+ offset += TarHeader.USTAR_DEVLEN;
+
+ header.namePrefix = TarHeader.parseName(bh, offset, TarHeader.USTAR_FILENAME_PREFIX);
+ }
+}
\ No newline at end of file
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarHeader.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarHeader.java
new file mode 100755
index 00000000..b9d3a86b
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarHeader.java
@@ -0,0 +1,243 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+import java.io.File;
+
+/**
+ * Header
+ *
+ *
+ * Offset Size Field
+ * 0 100 File name
+ * 100 8 File mode
+ * 108 8 Owner's numeric user ID
+ * 116 8 Group's numeric user ID
+ * 124 12 File size in bytes
+ * 136 12 Last modification time in numeric Unix time format
+ * 148 8 Checksum for header block
+ * 156 1 Link indicator (file type)
+ * 157 100 Name of linked file
+ *
+ *
+ *
+ * File Types
+ *
+ *
+ * Value Meaning
+ * '0' Normal file
+ * (ASCII NUL) Normal file (now obsolete)
+ * '1' Hard link
+ * '2' Symbolic link
+ * '3' Character special
+ * '4' Block special
+ * '5' Directory
+ * '6' FIFO
+ * '7' Contigous
+ *
+ *
+ *
+ *
+ * Ustar header
+ *
+ *
+ * Offset Size Field
+ * 257 6 UStar indicator "ustar"
+ * 263 2 UStar version "00"
+ * 265 32 Owner user name
+ * 297 32 Owner group name
+ * 329 8 Device major number
+ * 337 8 Device minor number
+ * 345 155 Filename prefix
+ *
+ */
+
+public class TarHeader {
+
+ /*
+ * Header
+ */
+ public static final int NAMELEN = 100;
+ public static final int MODELEN = 8;
+ public static final int UIDLEN = 8;
+ public static final int GIDLEN = 8;
+ public static final int SIZELEN = 12;
+ public static final int MODTIMELEN = 12;
+ public static final int CHKSUMLEN = 8;
+ public static final byte LF_OLDNORM = 0;
+
+ /*
+ * File Types
+ */
+ public static final byte LF_NORMAL = (byte) '0';
+ public static final byte LF_LINK = (byte) '1';
+ public static final byte LF_SYMLINK = (byte) '2';
+ public static final byte LF_CHR = (byte) '3';
+ public static final byte LF_BLK = (byte) '4';
+ public static final byte LF_DIR = (byte) '5';
+ public static final byte LF_FIFO = (byte) '6';
+ public static final byte LF_CONTIG = (byte) '7';
+
+ /*
+ * Ustar header
+ */
+
+ public static final String USTAR_MAGIC = "ustar"; // POSIX
+
+ public static final int USTAR_MAGICLEN = 8;
+ public static final int USTAR_USER_NAMELEN = 32;
+ public static final int USTAR_GROUP_NAMELEN = 32;
+ public static final int USTAR_DEVLEN = 8;
+ public static final int USTAR_FILENAME_PREFIX = 155;
+
+ // Header values
+ public StringBuffer name;
+ public int mode;
+ public int userId;
+ public int groupId;
+ public long size;
+ public long modTime;
+ public int checkSum;
+ public byte linkFlag;
+ public StringBuffer linkName;
+ public StringBuffer magic; // ustar indicator and version
+ public StringBuffer userName;
+ public StringBuffer groupName;
+ public int devMajor;
+ public int devMinor;
+ public StringBuffer namePrefix;
+
+ public TarHeader() {
+ this.magic = new StringBuffer(TarHeader.USTAR_MAGIC);
+
+ this.name = new StringBuffer();
+ this.linkName = new StringBuffer();
+
+ String user = System.getProperty("user.name", "");
+
+ if (user.length() > 31)
+ user = user.substring(0, 31);
+
+ this.userId = 0;
+ this.groupId = 0;
+ this.userName = new StringBuffer(user);
+ this.groupName = new StringBuffer("");
+ this.namePrefix = new StringBuffer();
+ }
+
+ /**
+ * Parse an entry name from a header buffer.
+ *
+ * @param name
+ * @param header
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ * @return The header's entry name.
+ */
+ public static StringBuffer parseName(byte[] header, int offset, int length) {
+ StringBuffer result = new StringBuffer(length);
+
+ int end = offset + length;
+ for (int i = offset; i < end; ++i) {
+ if (header[i] == 0)
+ break;
+ result.append((char) header[i]);
+ }
+
+ return result;
+ }
+
+ /**
+ * Determine the number of bytes in an entry name.
+ *
+ * @param name
+ * @param header
+ * The header buffer from which to parse.
+ * @param offset
+ * The offset into the buffer from which to parse.
+ * @param length
+ * The number of header bytes to parse.
+ * @return The number of bytes in a header's entry name.
+ */
+ public static int getNameBytes(StringBuffer name, byte[] buf, int offset, int length) {
+ int i;
+
+ for (i = 0; i < length && i < name.length(); ++i) {
+ buf[offset + i] = (byte) name.charAt(i);
+ }
+
+ for (; i < length; ++i) {
+ buf[offset + i] = 0;
+ }
+
+ return offset + length;
+ }
+
+ /**
+ * Creates a new header for a file/directory entry.
+ *
+ *
+ * @param name
+ * File name
+ * @param size
+ * File size in bytes
+ * @param modTime
+ * Last modification time in numeric Unix time format
+ * @param dir
+ * Is directory
+ *
+ * @return
+ */
+ public static TarHeader createHeader(String entryName, long size, long modTime, boolean dir) {
+ String name = entryName;
+ name = TarUtils.trim(name.replace(File.separatorChar, '/'), '/');
+
+ TarHeader header = new TarHeader();
+ header.linkName = new StringBuffer("");
+
+ if (name.length() > 100) {
+ header.namePrefix = new StringBuffer(name.substring(0, name.lastIndexOf('/')));
+ header.name = new StringBuffer(name.substring(name.lastIndexOf('/') + 1));
+ } else {
+ header.name = new StringBuffer(name);
+ }
+
+ if (dir) {
+ header.mode = 040755;
+ header.linkFlag = TarHeader.LF_DIR;
+ if (header.name.charAt(header.name.length() - 1) != '/') {
+ header.name.append("/");
+ }
+ header.size = 0;
+ } else {
+ header.mode = 0100644;
+ header.linkFlag = TarHeader.LF_NORMAL;
+ header.size = size;
+ }
+
+ header.modTime = modTime;
+ header.checkSum = 0;
+ header.devMajor = 0;
+ header.devMinor = 0;
+
+ return header;
+ }
+}
\ No newline at end of file
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarInputStream.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarInputStream.java
new file mode 100755
index 00000000..ec50a1b6
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarInputStream.java
@@ -0,0 +1,249 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * @author Kamran Zafar
+ *
+ */
+public class TarInputStream extends FilterInputStream {
+
+ private static final int SKIP_BUFFER_SIZE = 2048;
+ private TarEntry currentEntry;
+ private long currentFileSize;
+ private long bytesRead;
+ private boolean defaultSkip = false;
+
+ public TarInputStream(InputStream in) {
+ super(in);
+ currentFileSize = 0;
+ bytesRead = 0;
+ }
+
+ @Override
+ public boolean markSupported() {
+ return false;
+ }
+
+ /**
+ * Not supported
+ *
+ */
+ @Override
+ public synchronized void mark(int readlimit) {
+ }
+
+ /**
+ * Not supported
+ *
+ */
+ @Override
+ public synchronized void reset() throws IOException {
+ throw new IOException("mark/reset not supported");
+ }
+
+ /**
+ * Read a byte
+ *
+ * @see java.io.FilterInputStream#read()
+ */
+ @Override
+ public int read() throws IOException {
+ byte[] buf = new byte[1];
+
+ int res = this.read(buf, 0, 1);
+
+ if (res != -1) {
+ return 0xFF & buf[0];
+ }
+
+ return res;
+ }
+
+ /**
+ * Checks if the bytes being read exceed the entry size and adjusts the byte
+ * array length. Updates the byte counters
+ *
+ *
+ * @see java.io.FilterInputStream#read(byte[], int, int)
+ */
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ if (currentEntry != null) {
+ if (currentFileSize == currentEntry.getSize()) {
+ return -1;
+ } else if ((currentEntry.getSize() - currentFileSize) < len) {
+ len = (int) (currentEntry.getSize() - currentFileSize);
+ }
+ }
+
+ int br = super.read(b, off, len);
+
+ if (br != -1) {
+ if (currentEntry != null) {
+ currentFileSize += br;
+ }
+
+ bytesRead += br;
+ }
+
+ return br;
+ }
+
+ /**
+ * Returns the next entry in the tar file
+ *
+ * @return TarEntry
+ * @throws IOException
+ */
+ public TarEntry getNextEntry() throws IOException {
+ closeCurrentEntry();
+
+ byte[] header = new byte[TarConstants.HEADER_BLOCK];
+ byte[] theader = new byte[TarConstants.HEADER_BLOCK];
+ int tr = 0;
+
+ // Read full header
+ while (tr < TarConstants.HEADER_BLOCK) {
+ int res = read(theader, 0, TarConstants.HEADER_BLOCK - tr);
+
+ if (res < 0) {
+ break;
+ }
+
+ System.arraycopy(theader, 0, header, tr, res);
+ tr += res;
+ }
+
+ // Check if record is null
+ boolean eof = true;
+ for (byte b : header) {
+ if (b != 0) {
+ eof = false;
+ break;
+ }
+ }
+
+ if (!eof) {
+ currentEntry = new TarEntry(header);
+ }
+
+ return currentEntry;
+ }
+
+ /**
+ * Returns the current offset (in bytes) from the beginning of the stream.
+ * This can be used to find out at which point in a tar file an entry's content begins, for instance.
+ */
+ public long getCurrentOffset() {
+ return bytesRead;
+ }
+
+ /**
+ * Closes the current tar entry
+ *
+ * @throws IOException
+ */
+ protected void closeCurrentEntry() throws IOException {
+ if (currentEntry != null) {
+ if (currentEntry.getSize() > currentFileSize) {
+ // Not fully read, skip rest of the bytes
+ long bs = 0;
+ while (bs < currentEntry.getSize() - currentFileSize) {
+ long res = skip(currentEntry.getSize() - currentFileSize - bs);
+
+ if (res == 0 && currentEntry.getSize() - currentFileSize > 0) {
+ // I suspect file corruption
+ throw new IOException("Possible tar file corruption");
+ }
+
+ bs += res;
+ }
+ }
+
+ currentEntry = null;
+ currentFileSize = 0L;
+ skipPad();
+ }
+ }
+
+ /**
+ * Skips the pad at the end of each tar entry file content
+ *
+ * @throws IOException
+ */
+ protected void skipPad() throws IOException {
+ if (bytesRead > 0) {
+ int extra = (int) (bytesRead % TarConstants.DATA_BLOCK);
+
+ if (extra > 0) {
+ long bs = 0;
+ while (bs < TarConstants.DATA_BLOCK - extra) {
+ long res = skip(TarConstants.DATA_BLOCK - extra - bs);
+ bs += res;
+ }
+ }
+ }
+ }
+
+ /**
+ * Skips 'n' bytes on the InputStream
+ * Overrides default implementation of skip
+ *
+ */
+ @Override
+ public long skip(long n) throws IOException {
+ if (defaultSkip) {
+ // use skip method of parent stream
+ // may not work if skip not implemented by parent
+ long bs = super.skip(n);
+ bytesRead += bs;
+
+ return bs;
+ }
+
+ if (n <= 0) {
+ return 0;
+ }
+
+ long left = n;
+ byte[] sBuff = new byte[SKIP_BUFFER_SIZE];
+
+ while (left > 0) {
+ int res = read(sBuff, 0, (int) (left < SKIP_BUFFER_SIZE ? left : SKIP_BUFFER_SIZE));
+ if (res < 0) {
+ break;
+ }
+ left -= res;
+ }
+
+ return n - left;
+ }
+
+ public boolean isDefaultSkip() {
+ return defaultSkip;
+ }
+
+ public void setDefaultSkip(boolean defaultSkip) {
+ this.defaultSkip = defaultSkip;
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarOutputStream.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarOutputStream.java
new file mode 100755
index 00000000..ffdfe875
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarOutputStream.java
@@ -0,0 +1,163 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.RandomAccessFile;
+
+/**
+ * @author Kamran Zafar
+ *
+ */
+public class TarOutputStream extends OutputStream {
+ private final OutputStream out;
+ private long bytesWritten;
+ private long currentFileSize;
+ private TarEntry currentEntry;
+
+ public TarOutputStream(OutputStream out) {
+ this.out = out;
+ bytesWritten = 0;
+ currentFileSize = 0;
+ }
+
+ public TarOutputStream(final File fout) throws FileNotFoundException {
+ this.out = new BufferedOutputStream(new FileOutputStream(fout));
+ bytesWritten = 0;
+ currentFileSize = 0;
+ }
+
+ /**
+ * Opens a file for writing.
+ */
+ public TarOutputStream(final File fout, final boolean append) throws IOException {
+ @SuppressWarnings("resource")
+ RandomAccessFile raf = new RandomAccessFile(fout, "rw");
+ final long fileSize = fout.length();
+ if (append && fileSize > TarConstants.EOF_BLOCK) {
+ raf.seek(fileSize - TarConstants.EOF_BLOCK);
+ }
+ out = new BufferedOutputStream(new FileOutputStream(raf.getFD()));
+ }
+
+ /**
+ * Appends the EOF record and closes the stream
+ *
+ * @see java.io.FilterOutputStream#close()
+ */
+ @Override
+ public void close() throws IOException {
+ closeCurrentEntry();
+ write( new byte[TarConstants.EOF_BLOCK] );
+ out.close();
+ }
+ /**
+ * Writes a byte to the stream and updates byte counters
+ *
+ * @see java.io.FilterOutputStream#write(int)
+ */
+ @Override
+ public void write(int b) throws IOException {
+ out.write( b );
+ bytesWritten += 1;
+
+ if (currentEntry != null) {
+ currentFileSize += 1;
+ }
+ }
+
+ /**
+ * Checks if the bytes being written exceed the current entry size.
+ *
+ * @see java.io.FilterOutputStream#write(byte[], int, int)
+ */
+ @Override
+ public void write(byte[] b, int off, int len) throws IOException {
+ if (currentEntry != null && !currentEntry.isDirectory()) {
+ if (currentEntry.getSize() < currentFileSize + len) {
+ throw new IOException( "The current entry[" + currentEntry.getName() + "] size["
+ + currentEntry.getSize() + "] is smaller than the bytes[" + ( currentFileSize + len )
+ + "] being written." );
+ }
+ }
+
+ out.write( b, off, len );
+
+ bytesWritten += len;
+
+ if (currentEntry != null) {
+ currentFileSize += len;
+ }
+ }
+
+ /**
+ * Writes the next tar entry header on the stream
+ *
+ * @param entry
+ * @throws IOException
+ */
+ public void putNextEntry(TarEntry entry) throws IOException {
+ closeCurrentEntry();
+
+ byte[] header = new byte[TarConstants.HEADER_BLOCK];
+ entry.writeEntryHeader( header );
+
+ write( header );
+
+ currentEntry = entry;
+ }
+
+ /**
+ * Closes the current tar entry
+ *
+ * @throws IOException
+ */
+ protected void closeCurrentEntry() throws IOException {
+ if (currentEntry != null) {
+ if (currentEntry.getSize() > currentFileSize) {
+ throw new IOException( "The current entry[" + currentEntry.getName() + "] of size["
+ + currentEntry.getSize() + "] has not been fully written." );
+ }
+
+ currentEntry = null;
+ currentFileSize = 0;
+
+ pad();
+ }
+ }
+
+ /**
+ * Pads the last content block
+ *
+ * @throws IOException
+ */
+ protected void pad() throws IOException {
+ if (bytesWritten > 0) {
+ int extra = (int) ( bytesWritten % TarConstants.DATA_BLOCK );
+
+ if (extra > 0) {
+ write( new byte[TarConstants.DATA_BLOCK - extra] );
+ }
+ }
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarUtils.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarUtils.java
new file mode 100755
index 00000000..50165765
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kamranzafar/jtar/TarUtils.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2012 Kamran Zafar
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.kamranzafar.jtar;
+
+import java.io.File;
+
+/**
+ * @author Kamran
+ *
+ */
+public class TarUtils {
+ /**
+ * Determines the tar file size of the given folder/file path
+ *
+ * @param path
+ * @return
+ */
+ public static long calculateTarSize(File path) {
+ return tarSize(path) + TarConstants.EOF_BLOCK;
+ }
+
+ private static long tarSize(File dir) {
+ long size = 0;
+
+ if (dir.isFile()) {
+ return entrySize(dir.length());
+ } else {
+ File[] subFiles = dir.listFiles();
+
+ if (subFiles != null && subFiles.length > 0) {
+ for (File file : subFiles) {
+ if (file.isFile()) {
+ size += entrySize(file.length());
+ } else {
+ size += tarSize(file);
+ }
+ }
+ } else {
+ // Empty folder header
+ return TarConstants.HEADER_BLOCK;
+ }
+ }
+
+ return size;
+ }
+
+ private static long entrySize(long fileSize) {
+ long size = 0;
+ size += TarConstants.HEADER_BLOCK; // Header
+ size += fileSize; // File size
+
+ long extra = size % TarConstants.DATA_BLOCK;
+
+ if (extra > 0) {
+ size += (TarConstants.DATA_BLOCK - extra); // pad
+ }
+
+ return size;
+ }
+
+ public static String trim(String s, char c) {
+ StringBuffer tmp = new StringBuffer(s);
+ for (int i = 0; i < tmp.length(); i++) {
+ if (tmp.charAt(i) != c) {
+ break;
+ } else {
+ tmp.deleteCharAt(i);
+ }
+ }
+
+ for (int i = tmp.length() - 1; i >= 0; i--) {
+ if (tmp.charAt(i) != c) {
+ break;
+ } else {
+ tmp.deleteCharAt(i);
+ }
+ }
+
+ return tmp.toString();
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiver.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiver.java
new file mode 100644
index 00000000..58a1c5ed
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiver.java
@@ -0,0 +1,19 @@
+package org.kivy.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Intent;
+import android.content.Context;
+
+public class GenericBroadcastReceiver extends BroadcastReceiver {
+
+ GenericBroadcastReceiverCallback listener;
+
+ public GenericBroadcastReceiver(GenericBroadcastReceiverCallback listener) {
+ super();
+ this.listener = listener;
+ }
+
+ public void onReceive(Context context, Intent intent) {
+ this.listener.onReceive(context, intent);
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiverCallback.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiverCallback.java
new file mode 100644
index 00000000..1a87c98b
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/GenericBroadcastReceiverCallback.java
@@ -0,0 +1,8 @@
+package org.kivy.android;
+
+import android.content.Intent;
+import android.content.Context;
+
+public interface GenericBroadcastReceiverCallback {
+ void onReceive(Context context, Intent intent);
+};
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonActivity.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonActivity.java
new file mode 100644
index 00000000..7fcae698
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonActivity.java
@@ -0,0 +1,479 @@
+
+package org.kivy.android;
+
+import java.io.InputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.File;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+
+import android.view.ViewGroup;
+import android.view.SurfaceView;
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+import android.widget.Toast;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.graphics.PixelFormat;
+import android.view.SurfaceHolder;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ApplicationInfo;
+import android.content.Intent;
+import android.widget.ImageView;
+import java.io.InputStream;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+
+import org.libsdl.app.SDLActivity;
+
+import org.kivy.android.PythonUtil;
+import org.kivy.android.launcher.Project;
+
+import org.renpy.android.ResourceManager;
+import org.renpy.android.AssetExtract;
+
+
+public class PythonActivity extends SDLActivity {
+ private static final String TAG = "PythonActivity";
+
+ public static PythonActivity mActivity = null;
+
+ private ResourceManager resourceManager = null;
+ private Bundle mMetaData = null;
+ private PowerManager.WakeLock mWakeLock = null;
+
+ public String getAppRoot() {
+ String app_root = getFilesDir().getAbsolutePath() + "/app";
+ return app_root;
+ }
+
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ Log.v(TAG, "My oncreate running");
+ resourceManager = new ResourceManager(this);
+
+ Log.v(TAG, "About to do super onCreate");
+ super.onCreate(savedInstanceState);
+ Log.v(TAG, "Did super onCreate");
+
+ this.mActivity = this;
+ this.showLoadingScreen();
+
+ new UnpackFilesTask().execute(getAppRoot());
+ }
+
+ public void loadLibraries() {
+ String app_root = new String(getAppRoot());
+ File app_root_file = new File(app_root);
+ PythonUtil.loadLibraries(app_root_file);
+ }
+
+ public void recursiveDelete(File f) {
+ if (f.isDirectory()) {
+ for (File r : f.listFiles()) {
+ recursiveDelete(r);
+ }
+ }
+ f.delete();
+ }
+
+ /**
+ * Show an error using a toast. (Only makes sense from non-UI
+ * threads.)
+ */
+ public void toastError(final String msg) {
+
+ final Activity thisActivity = this;
+
+ runOnUiThread(new Runnable () {
+ public void run() {
+ Toast.makeText(thisActivity, msg, Toast.LENGTH_LONG).show();
+ }
+ });
+
+ // Wait to show the error.
+ synchronized (this) {
+ try {
+ this.wait(1000);
+ } catch (InterruptedException e) {
+ }
+ }
+ }
+
+ private class UnpackFilesTask extends AsyncTask {
+ @Override
+ protected String doInBackground(String... params) {
+ File app_root_file = new File(params[0]);
+ Log.v(TAG, "Ready to unpack");
+ unpackData("private", app_root_file);
+ return null;
+ }
+
+ @Override
+ protected void onPostExecute(String result) {
+ // Figure out the directory where the game is. If the game was
+ // given to us via an intent, then we use the scheme-specific
+ // part of that intent to determine the file to launch. We
+ // also use the android.txt file to determine the orientation.
+ //
+ // Otherwise, we use the public data, if we have it, or the
+ // private data if we do not.
+ mActivity.finishLoad();
+
+ // finishLoad called setContentView with the SDL view, which
+ // removed the loading screen. However, we still need it to
+ // show until the app is ready to render, so pop it back up
+ // on top of the SDL view.
+ mActivity.showLoadingScreen();
+
+ String app_root_dir = getAppRoot();
+ if (getIntent() != null && getIntent().getAction() != null &&
+ getIntent().getAction().equals("org.kivy.LAUNCH")) {
+ File path = new File(getIntent().getData().getSchemeSpecificPart());
+
+ Project p = Project.scanDirectory(path);
+ SDLActivity.nativeSetEnv("ANDROID_ENTRYPOINT", p.dir + "/main.py");
+ SDLActivity.nativeSetEnv("ANDROID_ARGUMENT", p.dir);
+ SDLActivity.nativeSetEnv("ANDROID_APP_PATH", p.dir);
+
+ if (p != null) {
+ if (p.landscape) {
+ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+ } else {
+ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+ }
+ }
+
+ // Let old apps know they started.
+ try {
+ FileWriter f = new FileWriter(new File(path, ".launch"));
+ f.write("started");
+ f.close();
+ } catch (IOException e) {
+ // pass
+ }
+ } else {
+ SDLActivity.nativeSetEnv("ANDROID_ENTRYPOINT", "main.pyo");
+ SDLActivity.nativeSetEnv("ANDROID_ARGUMENT", app_root_dir);
+ SDLActivity.nativeSetEnv("ANDROID_APP_PATH", app_root_dir);
+ }
+
+ String mFilesDirectory = mActivity.getFilesDir().getAbsolutePath();
+ Log.v(TAG, "Setting env vars for start.c and Python to use");
+ SDLActivity.nativeSetEnv("ANDROID_PRIVATE", mFilesDirectory);
+ SDLActivity.nativeSetEnv("PYTHONHOME", app_root_dir);
+ SDLActivity.nativeSetEnv("PYTHONPATH", app_root_dir + ":" + app_root_dir + "/lib");
+ SDLActivity.nativeSetEnv("PYTHONOPTIMIZE", "2");
+
+ try {
+ Log.v(TAG, "Access to our meta-data...");
+ mActivity.mMetaData = mActivity.getPackageManager().getApplicationInfo(
+ mActivity.getPackageName(), PackageManager.GET_META_DATA).metaData;
+
+ PowerManager pm = (PowerManager) mActivity.getSystemService(Context.POWER_SERVICE);
+ if ( mActivity.mMetaData.getInt("wakelock") == 1 ) {
+ mActivity.mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "Screen On");
+ mActivity.mWakeLock.acquire();
+ }
+ if ( mActivity.mMetaData.getInt("surface.transparent") != 0 ) {
+ Log.v(TAG, "Surface will be transparent.");
+ getSurface().setZOrderOnTop(true);
+ getSurface().getHolder().setFormat(PixelFormat.TRANSPARENT);
+ } else {
+ Log.i(TAG, "Surface will NOT be transparent");
+ }
+ } catch (PackageManager.NameNotFoundException e) {
+ }
+ }
+
+ @Override
+ protected void onPreExecute() {
+ }
+
+ @Override
+ protected void onProgressUpdate(Void... values) {
+ }
+ }
+
+ public void unpackData(final String resource, File target) {
+
+ Log.v(TAG, "UNPACKING!!! " + resource + " " + target.getName());
+
+ // The version of data in memory and on disk.
+ String data_version = resourceManager.getString(resource + "_version");
+ String disk_version = null;
+
+ Log.v(TAG, "Data version is " + data_version);
+
+ // If no version, no unpacking is necessary.
+ if (data_version == null) {
+ return;
+ }
+
+ // Check the current disk version, if any.
+ String filesDir = target.getAbsolutePath();
+ String disk_version_fn = filesDir + "/" + resource + ".version";
+
+ try {
+ byte buf[] = new byte[64];
+ InputStream is = new FileInputStream(disk_version_fn);
+ int len = is.read(buf);
+ disk_version = new String(buf, 0, len);
+ is.close();
+ } catch (Exception e) {
+ disk_version = "";
+ }
+
+ // If the disk data is out of date, extract it and write the
+ // version file.
+ // if (! data_version.equals(disk_version)) {
+ if (! data_version.equals(disk_version)) {
+ Log.v(TAG, "Extracting " + resource + " assets.");
+
+ recursiveDelete(target);
+ target.mkdirs();
+
+ AssetExtract ae = new AssetExtract(this);
+ if (!ae.extractTar(resource + ".mp3", target.getAbsolutePath())) {
+ toastError("Could not extract " + resource + " data.");
+ }
+
+ try {
+ // Write .nomedia.
+ new File(target, ".nomedia").createNewFile();
+
+ // Write version file.
+ FileOutputStream os = new FileOutputStream(disk_version_fn);
+ os.write(data_version.getBytes());
+ os.close();
+ } catch (Exception e) {
+ Log.w("python", e);
+ }
+ }
+ }
+
+ public static ViewGroup getLayout() {
+ return mLayout;
+ }
+
+ public static SurfaceView getSurface() {
+ return mSurface;
+ }
+
+ //----------------------------------------------------------------------------
+ // Listener interface for onNewIntent
+ //
+
+ public interface NewIntentListener {
+ void onNewIntent(Intent intent);
+ }
+
+ private List newIntentListeners = null;
+
+ public void registerNewIntentListener(NewIntentListener listener) {
+ if ( this.newIntentListeners == null )
+ this.newIntentListeners = Collections.synchronizedList(new ArrayList());
+ this.newIntentListeners.add(listener);
+ }
+
+ public void unregisterNewIntentListener(NewIntentListener listener) {
+ if ( this.newIntentListeners == null )
+ return;
+ this.newIntentListeners.remove(listener);
+ }
+
+ @Override
+ protected void onNewIntent(Intent intent) {
+ if ( this.newIntentListeners == null )
+ return;
+ this.onResume();
+ synchronized ( this.newIntentListeners ) {
+ Iterator iterator = this.newIntentListeners.iterator();
+ while ( iterator.hasNext() ) {
+ (iterator.next()).onNewIntent(intent);
+ }
+ }
+ }
+
+ //----------------------------------------------------------------------------
+ // Listener interface for onActivityResult
+ //
+
+ public interface ActivityResultListener {
+ void onActivityResult(int requestCode, int resultCode, Intent data);
+ }
+
+ private List activityResultListeners = null;
+
+ public void registerActivityResultListener(ActivityResultListener listener) {
+ if ( this.activityResultListeners == null )
+ this.activityResultListeners = Collections.synchronizedList(new ArrayList());
+ this.activityResultListeners.add(listener);
+ }
+
+ public void unregisterActivityResultListener(ActivityResultListener listener) {
+ if ( this.activityResultListeners == null )
+ return;
+ this.activityResultListeners.remove(listener);
+ }
+
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+ if ( this.activityResultListeners == null )
+ return;
+ this.onResume();
+ synchronized ( this.activityResultListeners ) {
+ Iterator iterator = this.activityResultListeners.iterator();
+ while ( iterator.hasNext() )
+ (iterator.next()).onActivityResult(requestCode, resultCode, intent);
+ }
+ }
+
+ public static void start_service(String serviceTitle, String serviceDescription,
+ String pythonServiceArgument) {
+ Intent serviceIntent = new Intent(PythonActivity.mActivity, PythonService.class);
+ String argument = PythonActivity.mActivity.getFilesDir().getAbsolutePath();
+ String filesDirectory = argument;
+ String app_root_dir = PythonActivity.mActivity.getAppRoot();
+ serviceIntent.putExtra("androidPrivate", argument);
+ serviceIntent.putExtra("androidArgument", app_root_dir);
+ serviceIntent.putExtra("serviceEntrypoint", "service/main.pyo");
+ serviceIntent.putExtra("pythonHome", app_root_dir);
+ serviceIntent.putExtra("pythonPath", app_root_dir + ":" + app_root_dir + "/lib");
+ serviceIntent.putExtra("serviceTitle", serviceTitle);
+ serviceIntent.putExtra("serviceDescription", serviceDescription);
+ serviceIntent.putExtra("pythonServiceArgument", pythonServiceArgument);
+ PythonActivity.mActivity.startService(serviceIntent);
+ }
+
+ public static void stop_service() {
+ Intent serviceIntent = new Intent(PythonActivity.mActivity, PythonService.class);
+ PythonActivity.mActivity.stopService(serviceIntent);
+ }
+
+ /** Loading screen implementation
+ * keepActive() is a method plugged in pollInputDevices in SDLActivity.
+ * Once it's called twice, the loading screen will be removed.
+ * The first call happen as soon as the window is created, but no image has been
+ * displayed first. My tests showed that we can wait one more. This might delay
+ * the real available of few hundred milliseconds.
+ * The real deal is to know if a rendering has already happen. The previous
+ * python-for-android and kivy was having something for that, but this new version
+ * is not compatible, and would require a new kivy version.
+ * In case of, the method PythonActivty.mActivity.removeLoadingScreen() can be called.
+ */
+ public static ImageView mImageView = null;
+ int mLoadingCount = 2;
+
+ @Override
+ public void keepActive() {
+ if (this.mLoadingCount > 0) {
+ this.mLoadingCount -= 1;
+ if (this.mLoadingCount == 0) {
+ this.removeLoadingScreen();
+ }
+ }
+ }
+
+ public void removeLoadingScreen() {
+ runOnUiThread(new Runnable() {
+ public void run() {
+ if (PythonActivity.mImageView != null &&
+ PythonActivity.mImageView.getParent() != null) {
+ ((ViewGroup)PythonActivity.mImageView.getParent()).removeView(
+ PythonActivity.mImageView);
+ PythonActivity.mImageView = null;
+ }
+ }
+ });
+ }
+
+
+ protected void showLoadingScreen() {
+ // load the bitmap
+ // 1. if the image is valid and we don't have layout yet, assign this bitmap
+ // as main view.
+ // 2. if we have a layout, just set it in the layout.
+ // 3. If we have an mImageView already, then do nothing because it will have
+ // already been made the content view or added to the layout.
+
+ if (mImageView == null) {
+ int presplashId = this.resourceManager.getIdentifier("presplash", "drawable");
+ InputStream is = this.getResources().openRawResource(presplashId);
+ Bitmap bitmap = null;
+ try {
+ bitmap = BitmapFactory.decodeStream(is);
+ } finally {
+ try {
+ is.close();
+ } catch (IOException e) {};
+ }
+
+ mImageView = new ImageView(this);
+ mImageView.setImageBitmap(bitmap);
+
+ /*
+ * Set the presplash loading screen background color
+ * https://developer.android.com/reference/android/graphics/Color.html
+ * Parse the color string, and return the corresponding color-int.
+ * If the string cannot be parsed, throws an IllegalArgumentException exception.
+ * Supported formats are: #RRGGBB #AARRGGBB or one of the following names:
+ * 'red', 'blue', 'green', 'black', 'white', 'gray', 'cyan', 'magenta', 'yellow',
+ * 'lightgray', 'darkgray', 'grey', 'lightgrey', 'darkgrey', 'aqua', 'fuchsia',
+ * 'lime', 'maroon', 'navy', 'olive', 'purple', 'silver', 'teal'.
+ */
+ String backgroundColor = resourceManager.getString("presplash_color");
+ if (backgroundColor != null) {
+ try {
+ mImageView.setBackgroundColor(Color.parseColor(backgroundColor));
+ } catch (IllegalArgumentException e) {}
+ }
+ mImageView.setLayoutParams(new ViewGroup.LayoutParams(
+ ViewGroup.LayoutParams.FILL_PARENT,
+ ViewGroup.LayoutParams.FILL_PARENT));
+ mImageView.setScaleType(ImageView.ScaleType.FIT_CENTER);
+
+ }
+
+ if (mLayout == null) {
+ setContentView(mImageView);
+ } else if (PythonActivity.mImageView.getParent() == null){
+ mLayout.addView(mImageView);
+ }
+
+ }
+
+ @Override
+ protected void onPause() {
+ // fooabc
+ if ( this.mWakeLock != null && mWakeLock.isHeld()){
+ this.mWakeLock.release();
+ }
+
+ Log.v(TAG, "onPause()");
+ super.onPause();
+ }
+
+ @Override
+ protected void onResume() {
+ if ( this.mWakeLock != null){
+ this.mWakeLock.acquire();
+ }
+ Log.v(TAG, "onResume()");
+ super.onResume();
+ }
+
+
+
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonService.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonService.java
new file mode 100644
index 00000000..ea1c9855
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonService.java
@@ -0,0 +1,132 @@
+package org.kivy.android;
+
+import android.app.Service;
+import android.os.IBinder;
+import android.os.Bundle;
+import android.content.Intent;
+import android.content.Context;
+import android.util.Log;
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.os.Process;
+import java.io.File;
+
+import org.kivy.android.PythonUtil;
+
+import org.renpy.android.Hardware;
+
+
+public class PythonService extends Service implements Runnable {
+
+ // Thread for Python code
+ private Thread pythonThread = null;
+
+ // Python environment variables
+ private String androidPrivate;
+ private String androidArgument;
+ private String pythonName;
+ private String pythonHome;
+ private String pythonPath;
+ private String serviceEntrypoint;
+ // Argument to pass to Python code,
+ private String pythonServiceArgument;
+ public static PythonService mService = null;
+ private Intent startIntent = null;
+
+ private boolean autoRestartService = false;
+
+ public void setAutoRestartService(boolean restart) {
+ autoRestartService = restart;
+ }
+
+ public boolean canDisplayNotification() {
+ return true;
+ }
+
+ public int startType() {
+ return START_NOT_STICKY;
+ }
+
+ @Override
+ public IBinder onBind(Intent arg0) {
+ return null;
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ if (pythonThread != null) {
+ Log.v("python service", "service exists, do not start again");
+ return START_NOT_STICKY;
+ }
+
+ startIntent = intent;
+ Bundle extras = intent.getExtras();
+ androidPrivate = extras.getString("androidPrivate");
+ androidArgument = extras.getString("androidArgument");
+ serviceEntrypoint = extras.getString("serviceEntrypoint");
+ pythonName = extras.getString("pythonName");
+ pythonHome = extras.getString("pythonHome");
+ pythonPath = extras.getString("pythonPath");
+ pythonServiceArgument = extras.getString("pythonServiceArgument");
+
+ pythonThread = new Thread(this);
+ pythonThread.start();
+
+ if (canDisplayNotification()) {
+ doStartForeground(extras);
+ }
+
+ return startType();
+ }
+
+ protected void doStartForeground(Bundle extras) {
+ String serviceTitle = extras.getString("serviceTitle");
+ String serviceDescription = extras.getString("serviceDescription");
+
+ Context context = getApplicationContext();
+ Notification notification = new Notification(context.getApplicationInfo().icon,
+ serviceTitle, System.currentTimeMillis());
+ Intent contextIntent = new Intent(context, PythonActivity.class);
+ PendingIntent pIntent = PendingIntent.getActivity(context, 0, contextIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT);
+ notification.setLatestEventInfo(context, serviceTitle, serviceDescription, pIntent);
+ startForeground(1, notification);
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ pythonThread = null;
+ if (autoRestartService && startIntent != null) {
+ Log.v("python service", "service restart requested");
+ startService(startIntent);
+ }
+ Process.killProcess(Process.myPid());
+ }
+
+ @Override
+ public void run(){
+ String app_root = getFilesDir().getAbsolutePath() + "/app";
+ File app_root_file = new File(app_root);
+ PythonUtil.loadLibraries(app_root_file);
+ this.mService = this;
+ nativeStart(
+ androidPrivate, androidArgument,
+ serviceEntrypoint, pythonName,
+ pythonHome, pythonPath,
+ pythonServiceArgument);
+ stopSelf();
+ }
+
+ // Native part
+ public static native void nativeStart(
+ String androidPrivate, String androidArgument,
+ String serviceEntrypoint, String pythonName,
+ String pythonHome, String pythonPath,
+ String pythonServiceArgument);
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonUtil.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonUtil.java
new file mode 100644
index 00000000..3c6f2865
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/PythonUtil.java
@@ -0,0 +1,62 @@
+package org.kivy.android;
+
+import java.io.File;
+
+import android.util.Log;
+
+
+public class PythonUtil {
+ private static final String TAG = "PythonUtil";
+
+ protected static String[] getLibraries() {
+ return new String[] {
+ "SDL2",
+ "SDL2_image",
+ "SDL2_mixer",
+ "SDL2_ttf",
+ "python2.7",
+ "python3.5m",
+ "python3.6m",
+ "main"
+ };
+ }
+
+ public static void loadLibraries(File filesDir) {
+
+ String filesDirPath = filesDir.getAbsolutePath();
+ boolean foundPython = false;
+
+ for (String lib : getLibraries()) {
+ try {
+ System.loadLibrary(lib);
+ if (lib.startsWith("python")) {
+ foundPython = true;
+ }
+ } catch(UnsatisfiedLinkError e) {
+ // If this is the last possible libpython
+ // load, and it has failed, give a more
+ // general error
+ if (lib.startsWith("python3.6") && !foundPython) {
+ throw new java.lang.RuntimeException("Could not load any libpythonXXX.so");
+ }
+ continue;
+ }
+ }
+
+ try {
+ System.load(filesDirPath + "/lib/python2.7/lib-dynload/_io.so");
+ System.load(filesDirPath + "/lib/python2.7/lib-dynload/unicodedata.so");
+ } catch(UnsatisfiedLinkError e) {
+ Log.v(TAG, "Failed to load _io.so or unicodedata.so...but that's okay.");
+ }
+
+ try {
+ // System.loadLibrary("ctypes");
+ System.load(filesDirPath + "/lib/python2.7/lib-dynload/_ctypes.so");
+ } catch(UnsatisfiedLinkError e) {
+ Log.v(TAG, "Unsatisfied linker when loading ctypes");
+ }
+
+ Log.v(TAG, "Loaded everything!");
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonEvent.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonEvent.java
new file mode 100644
index 00000000..9911356b
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonEvent.java
@@ -0,0 +1,45 @@
+package org.kivy.android.concurrency;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Created by ryan on 3/28/14.
+ */
+public class PythonEvent {
+ private final Lock lock = new ReentrantLock();
+ private final Condition cond = lock.newCondition();
+ private boolean flag = false;
+
+ public void set() {
+ lock.lock();
+ try {
+ flag = true;
+ cond.signalAll();
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ public void wait_() throws InterruptedException {
+ lock.lock();
+ try {
+ while (!flag) {
+ cond.await();
+ }
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ public void clear() {
+ lock.lock();
+ try {
+ flag = false;
+ cond.signalAll();
+ } finally {
+ lock.unlock();
+ }
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonLock.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonLock.java
new file mode 100644
index 00000000..22f9d903
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/concurrency/PythonLock.java
@@ -0,0 +1,19 @@
+package org.kivy.android.concurrency;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Created by ryan on 3/28/14.
+ */
+public class PythonLock {
+ private final Lock lock = new ReentrantLock();
+
+ public void acquire() {
+ lock.lock();
+ }
+
+ public void release() {
+ lock.unlock();
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/Project.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/Project.java
new file mode 100644
index 00000000..9177b43b
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/Project.java
@@ -0,0 +1,99 @@
+package org.kivy.android.launcher;
+
+import java.io.UnsupportedEncodingException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.Properties;
+
+import android.util.Log;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+
+
+/**
+ * This represents a project we've scanned for.
+ */
+public class Project {
+
+ public String dir = null;
+ String title = null;
+ String author = null;
+ Bitmap icon = null;
+ public boolean landscape = false;
+
+ static String decode(String s) {
+ try {
+ return new String(s.getBytes("ISO-8859-1"), "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ return s;
+ }
+ }
+
+ /**
+ * Scans directory for a android.txt file. If it finds one,
+ * and it looks valid enough, then it creates a new Project,
+ * and returns that. Otherwise, returns null.
+ */
+ public static Project scanDirectory(File dir) {
+
+ // We might have a link file.
+ if (dir.getAbsolutePath().endsWith(".link")) {
+ try {
+
+ // Scan the android.txt file.
+ File propfile = new File(dir, "android.txt");
+ FileInputStream in = new FileInputStream(propfile);
+ Properties p = new Properties();
+ p.load(in);
+ in.close();
+
+ String directory = p.getProperty("directory", null);
+
+ if (directory == null) {
+ return null;
+ }
+
+ dir = new File(directory);
+
+ } catch (Exception e) {
+ Log.i("Project", "Couldn't open link file " + dir, e);
+ }
+ }
+
+ // Make sure we're dealing with a directory.
+ if (! dir.isDirectory()) {
+ return null;
+ }
+
+ try {
+
+ // Scan the android.txt file.
+ File propfile = new File(dir, "android.txt");
+ FileInputStream in = new FileInputStream(propfile);
+ Properties p = new Properties();
+ p.load(in);
+ in.close();
+
+ // Get the various properties.
+ String title = decode(p.getProperty("title", "Untitled"));
+ String author = decode(p.getProperty("author", ""));
+ boolean landscape = p.getProperty("orientation", "portrait").equals("landscape");
+
+ // Create the project object.
+ Project rv = new Project();
+ rv.title = title;
+ rv.author = author;
+ rv.icon = BitmapFactory.decodeFile(new File(dir, "icon.png").getAbsolutePath());
+ rv.landscape = landscape;
+ rv.dir = dir.getAbsolutePath();
+
+ return rv;
+
+ } catch (Exception e) {
+ Log.i("Project", "Couldn't open android.txt", e);
+ }
+
+ return null;
+
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectAdapter.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectAdapter.java
new file mode 100644
index 00000000..f66debfe
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectAdapter.java
@@ -0,0 +1,44 @@
+package org.kivy.android.launcher;
+
+import android.app.Activity;
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Gravity;
+import android.widget.ArrayAdapter;
+import android.widget.TextView;
+import android.widget.LinearLayout;
+import android.widget.ImageView;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Log;
+
+import org.renpy.android.ResourceManager;
+
+public class ProjectAdapter extends ArrayAdapter {
+
+ private Activity mContext;
+ private ResourceManager resourceManager;
+
+ public ProjectAdapter(Activity context) {
+ super(context, 0);
+
+ mContext = context;
+ resourceManager = new ResourceManager(context);
+ }
+
+ public View getView(int position, View convertView, ViewGroup parent) {
+ Project p = getItem(position);
+
+ View v = resourceManager.inflateView("chooser_item");
+ TextView title = (TextView) resourceManager.getViewById(v, "title");
+ TextView author = (TextView) resourceManager.getViewById(v, "author");
+ ImageView icon = (ImageView) resourceManager.getViewById(v, "icon");
+
+ title.setText(p.title);
+ author.setText(p.author);
+ icon.setImageBitmap(p.icon);
+
+ return v;
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectChooser.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectChooser.java
new file mode 100644
index 00000000..17eec32f
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/kivy/android/launcher/ProjectChooser.java
@@ -0,0 +1,94 @@
+package org.kivy.android.launcher;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+import android.content.Intent;
+import android.content.res.Resources;
+import android.util.Log;
+import android.view.View;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.AdapterView;
+import android.os.Environment;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import android.net.Uri;
+
+import org.renpy.android.ResourceManager;
+
+public class ProjectChooser extends Activity implements AdapterView.OnItemClickListener {
+
+ ResourceManager resourceManager;
+
+ String urlScheme;
+
+ @Override
+ public void onStart()
+ {
+ super.onStart();
+
+ resourceManager = new ResourceManager(this);
+
+ urlScheme = resourceManager.getString("urlScheme");
+
+ // Set the window title.
+ setTitle(resourceManager.getString("appName"));
+
+ // Scan the sdcard for files, and sort them.
+ File dir = new File(Environment.getExternalStorageDirectory(), urlScheme);
+
+ File entries[] = dir.listFiles();
+
+ if (entries == null) {
+ entries = new File[0];
+ }
+
+ Arrays.sort(entries);
+
+ // Create a ProjectAdapter and fill it with projects.
+ ProjectAdapter projectAdapter = new ProjectAdapter(this);
+
+ // Populate it with the properties files.
+ for (File d : entries) {
+ Project p = Project.scanDirectory(d);
+ if (p != null) {
+ projectAdapter.add(p);
+ }
+ }
+
+ if (projectAdapter.getCount() != 0) {
+
+ View v = resourceManager.inflateView("project_chooser");
+ ListView l = (ListView) resourceManager.getViewById(v, "projectList");
+
+ l.setAdapter(projectAdapter);
+ l.setOnItemClickListener(this);
+
+ setContentView(v);
+
+ } else {
+
+ View v = resourceManager.inflateView("project_empty");
+ TextView emptyText = (TextView) resourceManager.getViewById(v, "emptyText");
+
+ emptyText.setText("No projects are available to launch. Please place a project into " + dir + " and restart this application. Press the back button to exit.");
+
+ setContentView(v);
+ }
+ }
+
+ public void onItemClick(AdapterView parent, View view, int position, long id) {
+ Project p = (Project) parent.getItemAtPosition(position);
+
+ Intent intent = new Intent(
+ "org.kivy.LAUNCH",
+ Uri.fromParts(urlScheme, p.dir, ""));
+
+ intent.setClassName(getPackageName(), "org.kivy.android.PythonActivity");
+ this.startActivity(intent);
+ this.finish();
+ }
+}
diff --git a/p4a/pythonforandroid/bootstraps/lbry/build/src/org/libsdl/app/SDLActivity.java b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/libsdl/app/SDLActivity.java
new file mode 100644
index 00000000..e1dc0846
--- /dev/null
+++ b/p4a/pythonforandroid/bootstraps/lbry/build/src/org/libsdl/app/SDLActivity.java
@@ -0,0 +1,1579 @@
+package org.libsdl.app;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.lang.reflect.Method;
+
+import android.app.*;
+import android.content.*;
+import android.view.*;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AbsoluteLayout;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.os.*;
+import android.util.Log;
+import android.util.SparseArray;
+import android.graphics.*;
+import android.graphics.drawable.Drawable;
+import android.media.*;
+import android.hardware.*;
+
+/**
+ SDL Activity
+*/
+public class SDLActivity extends Activity {
+ private static final String TAG = "SDL";
+
+ // Keep track of the paused state
+ public static boolean mIsPaused, mIsSurfaceReady, mHasFocus;
+ public static boolean mExitCalledFromJava;
+
+ /** If shared libraries (e.g. SDL or the native application) could not be loaded. */
+ public static boolean mBrokenLibraries;
+
+ // If we want to separate mouse and touch events.
+ // This is only toggled in native code when a hint is set!
+ public static boolean mSeparateMouseAndTouch;
+
+ // Main components
+ protected static SDLActivity mSingleton;
+ protected static SDLSurface mSurface;
+ protected static View mTextEdit;
+ protected static ViewGroup mLayout;
+ protected static SDLJoystickHandler mJoystickHandler;
+
+ // This is what SDL runs in. It invokes SDL_main(), eventually
+ protected static Thread mSDLThread;
+
+ // Audio
+ protected static AudioTrack mAudioTrack;
+
+ /**
+ * This method is called by SDL before loading the native shared libraries.
+ * It can be overridden to provide names of shared libraries to be loaded.
+ * The default implementation returns the defaults. It never returns null.
+ * An array returned by a new implementation must at least contain "SDL2".
+ * Also keep in mind that the order the libraries are loaded may matter.
+ * @return names of shared libraries to be loaded (e.g. "SDL2", "main").
+ */
+ protected String[] getLibraries() {
+ return new String[] {
+ "SDL2",
+ // "SDL2_image",
+ // "SDL2_mixer",
+ // "SDL2_net",
+ // "SDL2_ttf",
+ "main"
+ };
+ }
+
+ // Load the .so
+ public void loadLibraries() {
+ for (String lib : getLibraries()) {
+ System.loadLibrary(lib);
+ }
+ }
+
+ /**
+ * This method is called by SDL before starting the native application thread.
+ * It can be overridden to provide the arguments after the application name.
+ * The default implementation returns an empty array. It never returns null.
+ * @return arguments for the native application.
+ */
+ protected String[] getArguments() {
+ return new String[0];
+ }
+
+ public static void initialize() {
+ // The static nature of the singleton and Android quirkyness force us to initialize everything here
+ // Otherwise, when exiting the app and returning to it, these variables *keep* their pre exit values
+ mSingleton = null;
+ mSurface = null;
+ mTextEdit = null;
+ mLayout = null;
+ mJoystickHandler = null;
+ mSDLThread = null;
+ mAudioTrack = null;
+ mExitCalledFromJava = false;
+ mBrokenLibraries = false;
+ mIsPaused = false;
+ mIsSurfaceReady = false;
+ mHasFocus = true;
+ }
+
+ // Setup
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ Log.v("SDL", "Device: " + android.os.Build.DEVICE);
+ Log.v("SDL", "Model: " + android.os.Build.MODEL);
+ Log.v("SDL", "onCreate():" + mSingleton);
+ super.onCreate(savedInstanceState);
+
+ SDLActivity.initialize();
+ // So we can call stuff from static callbacks
+ mSingleton = this;
+ }
+
+ // We don't do this in onCreate because we unpack and load the app data on a thread
+ // and we can't run setup tasks until that thread completes.
+ protected void finishLoad() {
+ // Load shared libraries
+ String errorMsgBrokenLib = "";
+ try {
+ loadLibraries();
+ } catch(UnsatisfiedLinkError e) {
+ System.err.println(e.getMessage());
+ mBrokenLibraries = true;
+ errorMsgBrokenLib = e.getMessage();
+ } catch(Exception e) {
+ System.err.println(e.getMessage());
+ mBrokenLibraries = true;
+ errorMsgBrokenLib = e.getMessage();
+ }
+
+ if (mBrokenLibraries)
+ {
+ AlertDialog.Builder dlgAlert = new AlertDialog.Builder(this);
+ dlgAlert.setMessage("An error occurred while trying to start the application. Please try again and/or reinstall."
+ + System.getProperty("line.separator")
+ + System.getProperty("line.separator")
+ + "Error: " + errorMsgBrokenLib);
+ dlgAlert.setTitle("SDL Error");
+ dlgAlert.setPositiveButton("Exit",
+ new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog,int id) {
+ // if this button is clicked, close current activity
+ SDLActivity.mSingleton.finish();
+ }
+ });
+ dlgAlert.setCancelable(false);
+ dlgAlert.create().show();
+
+ return;
+ }
+
+ // Set up the surface
+ mSurface = new SDLSurface(getApplication());
+
+ if(Build.VERSION.SDK_INT >= 12) {
+ mJoystickHandler = new SDLJoystickHandler_API12();
+ }
+ else {
+ mJoystickHandler = new SDLJoystickHandler();
+ }
+
+ mLayout = new AbsoluteLayout(this);
+ mLayout.addView(mSurface);
+
+ setContentView(mLayout);
+ }
+
+ // Events
+ @Override
+ protected void onPause() {
+ Log.v("SDL", "onPause()");
+ super.onPause();
+
+ if (SDLActivity.mBrokenLibraries) {
+ return;
+ }
+
+ SDLActivity.handlePause();
+ }
+
+ @Override
+ protected void onResume() {
+ Log.v("SDL", "onResume()");
+ super.onResume();
+
+ if (SDLActivity.mBrokenLibraries) {
+ return;
+ }
+
+ SDLActivity.handleResume();
+ }
+
+
+ @Override
+ public void onWindowFocusChanged(boolean hasFocus) {
+ super.onWindowFocusChanged(hasFocus);
+ Log.v("SDL", "onWindowFocusChanged(): " + hasFocus);
+
+ if (SDLActivity.mBrokenLibraries) {
+ return;
+ }
+
+ SDLActivity.mHasFocus = hasFocus;
+ if (hasFocus) {
+ SDLActivity.handleResume();
+ }
+ }
+
+ @Override
+ public void onLowMemory() {
+ Log.v("SDL", "onLowMemory()");
+ super.onLowMemory();
+
+ if (SDLActivity.mBrokenLibraries) {
+ return;
+ }
+
+ SDLActivity.nativeLowMemory();
+ }
+
+ @Override
+ protected void onDestroy() {
+ Log.v("SDL", "onDestroy()");
+
+ if (SDLActivity.mBrokenLibraries) {
+ super.onDestroy();
+ // Reset everything in case the user re opens the app
+ SDLActivity.initialize();
+ return;
+ }
+
+ // Send a quit message to the application
+ SDLActivity.mExitCalledFromJava = true;
+ SDLActivity.nativeQuit();
+
+ // Now wait for the SDL thread to quit
+ if (SDLActivity.mSDLThread != null) {
+ try {
+ SDLActivity.mSDLThread.join();
+ } catch(Exception e) {
+ Log.v("SDL", "Problem stopping thread: " + e);
+ }
+ SDLActivity.mSDLThread = null;
+
+ //Log.v("SDL", "Finished waiting for SDL thread");
+ }
+
+ super.onDestroy();
+ // Reset everything in case the user re opens the app
+ SDLActivity.initialize();
+
+ // Completely closes application.
+ System.exit(0);
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+
+ if (SDLActivity.mBrokenLibraries) {
+ return false;
+ }
+
+ int keyCode = event.getKeyCode();
+ // Ignore certain special keys so they're handled by Android
+ if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
+ keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
+ keyCode == KeyEvent.KEYCODE_CAMERA ||
+ keyCode == 168 || /* API 11: KeyEvent.KEYCODE_ZOOM_IN */
+ keyCode == 169 /* API 11: KeyEvent.KEYCODE_ZOOM_OUT */
+ ) {
+ return false;
+ }
+ return super.dispatchKeyEvent(event);
+ }
+
+ /** Called by onPause or surfaceDestroyed. Even if surfaceDestroyed
+ * is the first to be called, mIsSurfaceReady should still be set
+ * to 'true' during the call to onPause (in a usual scenario).
+ */
+ public static void handlePause() {
+ if (!SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady) {
+ SDLActivity.mIsPaused = true;
+ SDLActivity.nativePause();
+ mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, false);
+ }
+ }
+
+ /** Called by onResume or surfaceCreated. An actual resume should be done only when the surface is ready.
+ * Note: Some Android variants may send multiple surfaceChanged events, so we don't need to resume
+ * every time we get one of those events, only if it comes after surfaceDestroyed
+ */
+ public static void handleResume() {
+ if (SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady && SDLActivity.mHasFocus) {
+ SDLActivity.mIsPaused = false;
+ SDLActivity.nativeResume();
+ mSurface.handleResume();
+ }
+ }
+
+ /* The native thread has finished */
+ public static void handleNativeExit() {
+ SDLActivity.mSDLThread = null;
+ mSingleton.finish();
+ }
+
+
+ // Messages from the SDLMain thread
+ static final int COMMAND_CHANGE_TITLE = 1;
+ static final int COMMAND_UNUSED = 2;
+ static final int COMMAND_TEXTEDIT_HIDE = 3;
+ static final int COMMAND_SET_KEEP_SCREEN_ON = 5;
+
+ protected static final int COMMAND_USER = 0x8000;
+
+ /**
+ * This method is called by SDL if SDL did not handle a message itself.
+ * This happens if a received message contains an unsupported command.
+ * Method can be overwritten to handle Messages in a different class.
+ * @param command the command of the message.
+ * @param param the parameter of the message. May be null.
+ * @return if the message was handled in overridden method.
+ */
+ protected boolean onUnhandledMessage(int command, Object param) {
+ return false;
+ }
+
+ /**
+ * A Handler class for Messages from native SDL applications.
+ * It uses current Activities as target (e.g. for the title).
+ * static to prevent implicit references to enclosing object.
+ */
+ protected static class SDLCommandHandler extends Handler {
+ @Override
+ public void handleMessage(Message msg) {
+ Context context = getContext();
+ if (context == null) {
+ Log.e(TAG, "error handling message, getContext() returned null");
+ return;
+ }
+ switch (msg.arg1) {
+ case COMMAND_CHANGE_TITLE:
+ if (context instanceof Activity) {
+ ((Activity) context).setTitle((String)msg.obj);
+ } else {
+ Log.e(TAG, "error handling message, getContext() returned no Activity");
+ }
+ break;
+ case COMMAND_TEXTEDIT_HIDE:
+ if (mTextEdit != null) {
+ mTextEdit.setVisibility(View.GONE);
+
+ InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+ imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);
+ }
+ break;
+ case COMMAND_SET_KEEP_SCREEN_ON:
+ {
+ Window window = ((Activity) context).getWindow();
+ if (window != null) {
+ if ((msg.obj instanceof Integer) && (((Integer) msg.obj).intValue() != 0)) {
+ window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ } else {
+ window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ }
+ }
+ break;
+ }
+ default:
+ if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
+ Log.e(TAG, "error handling message, command is " + msg.arg1);
+ }
+ }
+ }
+ }
+
+ // Handler for the messages
+ Handler commandHandler = new SDLCommandHandler();
+
+ // Send a message from the SDLMain thread
+ boolean sendCommand(int command, Object data) {
+ Message msg = commandHandler.obtainMessage();
+ msg.arg1 = command;
+ msg.obj = data;
+ return commandHandler.sendMessage(msg);
+ }
+
+ // C functions we call
+ public static native int nativeInit(Object arguments);
+ public static native void nativeLowMemory();
+ public static native void nativeQuit();
+ public static native void nativePause();
+ public static native void nativeResume();
+ public static native void onNativeResize(int x, int y, int format, float rate);
+ public static native int onNativePadDown(int device_id, int keycode);
+ public static native int onNativePadUp(int device_id, int keycode);
+ public static native void onNativeJoy(int device_id, int axis,
+ float value);
+ public static native void onNativeHat(int device_id, int hat_id,
+ int x, int y);
+ public static native void nativeSetEnv(String j_name, String j_value);
+ public static native void onNativeKeyDown(int keycode);
+ public static native void onNativeKeyUp(int keycode);
+ public static native void onNativeKeyboardFocusLost();
+ public static native void onNativeMouse(int button, int action, float x, float y);
+ public static native void onNativeTouch(int touchDevId, int pointerFingerId,
+ int action, float x,
+ float y, float p);
+ public static native void onNativeAccel(float x, float y, float z);
+ public static native void onNativeSurfaceChanged();
+ public static native void onNativeSurfaceDestroyed();
+ public static native void nativeFlipBuffers();
+ public static native int nativeAddJoystick(int device_id, String name,
+ int is_accelerometer, int nbuttons,
+ int naxes, int nhats, int nballs);
+ public static native int nativeRemoveJoystick(int device_id);
+ public static native String nativeGetHint(String name);
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static void flipBuffers() {
+ SDLActivity.nativeFlipBuffers();
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static boolean setActivityTitle(String title) {
+ // Called from SDLMain() thread and can't directly affect the view
+ return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static boolean sendMessage(int command, int param) {
+ return mSingleton.sendCommand(command, Integer.valueOf(param));
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static Context getContext() {
+ return mSingleton;
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ * @return result of getSystemService(name) but executed on UI thread.
+ */
+ public Object getSystemServiceFromUiThread(final String name) {
+ final Object lock = new Object();
+ final Object[] results = new Object[2]; // array for writable variables
+ synchronized (lock) {
+ runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ synchronized (lock) {
+ results[0] = getSystemService(name);
+ results[1] = Boolean.TRUE;
+ lock.notify();
+ }
+ }
+ });
+ if (results[1] == null) {
+ try {
+ lock.wait();
+ } catch (InterruptedException ex) {
+ ex.printStackTrace();
+ }
+ }
+ }
+ return results[0];
+ }
+
+ static class ShowTextInputTask implements Runnable {
+ /*
+ * This is used to regulate the pan&scan method to have some offset from
+ * the bottom edge of the input region and the top edge of an input
+ * method (soft keyboard)
+ */
+ static final int HEIGHT_PADDING = 15;
+
+ public int x, y, w, h;
+
+ public ShowTextInputTask(int x, int y, int w, int h) {
+ this.x = x;
+ this.y = y;
+ this.w = w;
+ this.h = h;
+ }
+
+ @Override
+ public void run() {
+ AbsoluteLayout.LayoutParams params = new AbsoluteLayout.LayoutParams(
+ w, h + HEIGHT_PADDING, x, y);
+
+ if (mTextEdit == null) {
+ mTextEdit = new DummyEdit(getContext());
+
+ mLayout.addView(mTextEdit, params);
+ } else {
+ mTextEdit.setLayoutParams(params);
+ }
+
+ mTextEdit.setVisibility(View.VISIBLE);
+ mTextEdit.requestFocus();
+
+ InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+ imm.showSoftInput(mTextEdit, 0);
+ }
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static boolean showTextInput(int x, int y, int w, int h) {
+ // Transfer the task to the main thread as a Runnable
+ return mSingleton.commandHandler.post(new ShowTextInputTask(x, y, w, h));
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static Surface getNativeSurface() {
+ return SDLActivity.mSurface.getNativeSurface();
+ }
+
+ // Audio
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static int audioInit(int sampleRate, boolean is16Bit, boolean isStereo, int desiredFrames) {
+ int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO : AudioFormat.CHANNEL_CONFIGURATION_MONO;
+ int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT : AudioFormat.ENCODING_PCM_8BIT;
+ int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);
+
+ Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono") + " " + (is16Bit ? "16-bit" : "8-bit") + " " + (sampleRate / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+
+ // Let the user pick a larger buffer if they really want -- but ye
+ // gods they probably shouldn't, the minimums are horrifyingly high
+ // latency already
+ desiredFrames = Math.max(desiredFrames, (AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat) + frameSize - 1) / frameSize);
+
+ if (mAudioTrack == null) {
+ mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
+ channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);
+
+ // Instantiating AudioTrack can "succeed" without an exception and the track may still be invalid
+ // Ref: https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/media/java/android/media/AudioTrack.java
+ // Ref: http://developer.android.com/reference/android/media/AudioTrack.html#getState()
+
+ if (mAudioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
+ Log.e("SDL", "Failed during initialization of Audio Track");
+ mAudioTrack = null;
+ return -1;
+ }
+
+ mAudioTrack.play();
+ }
+
+ Log.v("SDL", "SDL audio: got " + ((mAudioTrack.getChannelCount() >= 2) ? "stereo" : "mono") + " " + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit" : "8-bit") + " " + (mAudioTrack.getSampleRate() / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+
+ return 0;
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static void audioWriteShortBuffer(short[] buffer) {
+ for (int i = 0; i < buffer.length; ) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch(InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(short)");
+ return;
+ }
+ }
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static void audioWriteByteBuffer(byte[] buffer) {
+ for (int i = 0; i < buffer.length; ) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch(InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(byte)");
+ return;
+ }
+ }
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static void audioQuit() {
+ if (mAudioTrack != null) {
+ mAudioTrack.stop();
+ mAudioTrack = null;
+ }
+ }
+
+ // Input
+
+ /**
+ * This method is called by SDL using JNI.
+ * @return an array which may be empty but is never null.
+ */
+ public static int[] inputGetInputDeviceIds(int sources) {
+ int[] ids = InputDevice.getDeviceIds();
+ int[] filtered = new int[ids.length];
+ int used = 0;
+ for (int i = 0; i < ids.length; ++i) {
+ InputDevice device = InputDevice.getDevice(ids[i]);
+ if ((device != null) && ((device.getSources() & sources) != 0)) {
+ filtered[used++] = device.getId();
+ }
+ }
+ return Arrays.copyOf(filtered, used);
+ }
+
+ // Joystick glue code, just a series of stubs that redirect to the SDLJoystickHandler instance
+ public static boolean handleJoystickMotionEvent(MotionEvent event) {
+ return mJoystickHandler.handleMotionEvent(event);
+ }
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public static void pollInputDevices() {
+ if (SDLActivity.mSDLThread != null) {
+ mJoystickHandler.pollInputDevices();
+ SDLActivity.mSingleton.keepActive();
+ }
+ }
+
+ /**
+ * Trick needed for loading screen
+ */
+ public void keepActive() {
+ }
+
+ // APK extension files support
+
+ /** com.android.vending.expansion.zipfile.ZipResourceFile object or null. */
+ private Object expansionFile;
+
+ /** com.android.vending.expansion.zipfile.ZipResourceFile's getInputStream() or null. */
+ private Method expansionFileMethod;
+
+ /**
+ * This method is called by SDL using JNI.
+ */
+ public InputStream openAPKExtensionInputStream(String fileName) throws IOException {
+ // Get a ZipResourceFile representing a merger of both the main and patch files
+ if (expansionFile == null) {
+ Integer mainVersion = Integer.valueOf(nativeGetHint("SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION"));
+ Integer patchVersion = Integer.valueOf(nativeGetHint("SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION"));
+
+ try {
+ // To avoid direct dependency on Google APK extension library that is
+ // not a part of Android SDK we access it using reflection
+ expansionFile = Class.forName("com.android.vending.expansion.zipfile.APKExpansionSupport")
+ .getMethod("getAPKExpansionZipFile", Context.class, int.class, int.class)
+ .invoke(null, this, mainVersion, patchVersion);
+
+ expansionFileMethod = expansionFile.getClass()
+ .getMethod("getInputStream", String.class);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ expansionFile = null;
+ expansionFileMethod = null;
+ }
+ }
+
+ // Get an input stream for a known file inside the expansion file ZIPs
+ InputStream fileStream;
+ try {
+ fileStream = (InputStream)expansionFileMethod.invoke(expansionFile, fileName);
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ fileStream = null;
+ }
+
+ if (fileStream == null) {
+ throw new IOException();
+ }
+
+ return fileStream;
+ }
+
+ // Messagebox
+
+ /** Result of current messagebox. Also used for blocking the calling thread. */
+ protected final int[] messageboxSelection = new int[1];
+
+ /** Id of current dialog. */
+ protected int dialogs = 0;
+
+ /**
+ * This method is called by SDL using JNI.
+ * Shows the messagebox from UI thread and block calling thread.
+ * buttonFlags, buttonIds and buttonTexts must have same length.
+ * @param buttonFlags array containing flags for every button.
+ * @param buttonIds array containing id for every button.
+ * @param buttonTexts array containing text for every button.
+ * @param colors null for default or array of length 5 containing colors.
+ * @return button id or -1.
+ */
+ public int messageboxShowMessageBox(
+ final int flags,
+ final String title,
+ final String message,
+ final int[] buttonFlags,
+ final int[] buttonIds,
+ final String[] buttonTexts,
+ final int[] colors) {
+
+ messageboxSelection[0] = -1;
+
+ // sanity checks
+
+ if ((buttonFlags.length != buttonIds.length) && (buttonIds.length != buttonTexts.length)) {
+ return -1; // implementation broken
+ }
+
+ // collect arguments for Dialog
+
+ final Bundle args = new Bundle();
+ args.putInt("flags", flags);
+ args.putString("title", title);
+ args.putString("message", message);
+ args.putIntArray("buttonFlags", buttonFlags);
+ args.putIntArray("buttonIds", buttonIds);
+ args.putStringArray("buttonTexts", buttonTexts);
+ args.putIntArray("colors", colors);
+
+ // trigger Dialog creation on UI thread
+
+ runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ showDialog(dialogs++, args);
+ }
+ });
+
+ // block the calling thread
+
+ synchronized (messageboxSelection) {
+ try {
+ messageboxSelection.wait();
+ } catch (InterruptedException ex) {
+ ex.printStackTrace();
+ return -1;
+ }
+ }
+
+ // return selected value
+
+ return messageboxSelection[0];
+ }
+
+ @Override
+ protected Dialog onCreateDialog(int ignore, Bundle args) {
+
+ // TODO set values from "flags" to messagebox dialog
+
+ // get colors
+
+ int[] colors = args.getIntArray("colors");
+ int backgroundColor;
+ int textColor;
+ int buttonBorderColor;
+ int buttonBackgroundColor;
+ int buttonSelectedColor;
+ if (colors != null) {
+ int i = -1;
+ backgroundColor = colors[++i];
+ textColor = colors[++i];
+ buttonBorderColor = colors[++i];
+ buttonBackgroundColor = colors[++i];
+ buttonSelectedColor = colors[++i];
+ } else {
+ backgroundColor = Color.TRANSPARENT;
+ textColor = Color.TRANSPARENT;
+ buttonBorderColor = Color.TRANSPARENT;
+ buttonBackgroundColor = Color.TRANSPARENT;
+ buttonSelectedColor = Color.TRANSPARENT;
+ }
+
+ // create dialog with title and a listener to wake up calling thread
+
+ final Dialog dialog = new Dialog(this);
+ dialog.setTitle(args.getString("title"));
+ dialog.setCancelable(false);
+ dialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
+ @Override
+ public void onDismiss(DialogInterface unused) {
+ synchronized (messageboxSelection) {
+ messageboxSelection.notify();
+ }
+ }
+ });
+
+ // create text
+
+ TextView message = new TextView(this);
+ message.setGravity(Gravity.CENTER);
+ message.setText(args.getString("message"));
+ if (textColor != Color.TRANSPARENT) {
+ message.setTextColor(textColor);
+ }
+
+ // create buttons
+
+ int[] buttonFlags = args.getIntArray("buttonFlags");
+ int[] buttonIds = args.getIntArray("buttonIds");
+ String[] buttonTexts = args.getStringArray("buttonTexts");
+
+ final SparseArray