- Website: http://python-for-android.rtfd.org/

- Forum: https://groups.google.com/forum/?hl=fr#!forum/python-android

- Mailing list: python-android@googlegroups.com

Troubleshooting

if you get the following message:

Android NDK: Host 'awk' tool is outdated. Please define HOST_AWK to point to Gawk or Nawk !

a solution is to remove the "awk" binary in the android ndk distribution

rm $ANDROIDNDK/prebuilt/linux-x86/bin/awk

export LIBLINK_PATH="$BUILD_PATH/objects"

export LIBLINK="$ROOT_PATH/src/tools/liblink"

export BIGLINK="$ROOT_PATH/src/tools/biglink"

export OLD_LD=$LD

export LD="$TOOLCHAIN_PREFIX-ld"

export LD=$OLD_LD

test -d $LIBLINK_PATH || mkdir -p $LIBLINK_PATH

try mv libs/$ARCH/libpymodules.so private/

function run_biglink() {

push_arm

try $BIGLINK $LIBS_PATH/libpymodules.so $LIBLINK_PATH

pop_arm

}

run_biglink

function arm_deduplicate() {

fn=$(basename $1)

echo "== Trying to remove duplicate symbol in $1"

push_arm

try mkdir ddp

try cd ddp

try $AR x $1

try $AR rc $fn *.o

try $RANLIB $fn

try mv -f $fn $1

try cd ..

try rm -rf ddp

pop_arm

}

Android Python module

Python for android project include a python module named "android". This module is designed to give you an access to the Android API. As for today, the module is very limited, and waiting for contribution to wrap more Android API.

Example

::

How it's working

The whole Android API is accessible in Java. Their is no native or extensible way to access it from Python. The schema for accessing to their API is::

#. ``android.pyx`` is written in `Cython <http://cython.org/>`_: a language

with typed informations, very close to Python, that generate Python

extension. It's easier to write in Cython than CPython, and it's linked

directly to the part 2.

#. ``android_jni.c`` is defining simple c methods that access to Java

interfaces using JNI layer.

#. The last part contain the Java code that will be called from the JNI stuff.

All the source code is available at:

https://github.com/kivy/python-for-android/tree/master/recipes/android/src

API

android

.. module:: android

.. function:: check_pause()

This should be called on a regular basis to check to see if Android

expects the game to pause. If it return true, the game should

call :func:`android.wait_for_resume()`, after persisting its state

as necessary.

.. function:: wait_for_resume()

This function should be called after :func:`android.check_pause()`

returns true. It does not return until Android has resumed from

the pause. While in this function, Android may kill a game

without further notice.

.. function:: map_key(keycode, keysym)

This maps between an android keycode and a python keysym. The android

keycodes are available as constants in the android module.

.. function:: vibrate(s)

Causes the phone to vibrate for `s` seconds. This requires that your

application have the VIBRATE permission.

.. function:: accelerometer_enable(enable)

Enables (if `enable` is true) or disables the device's accelerometer.

.. function:: accelerometer_reading()

Returns an (x, y, z) tuple of floats that gives the accelerometer

reading, in meters per second squared. See `this page

<http://developer.android.com/reference/android/hardware/SensorEvent.html>`_

for a description of the coordinate system. The accelerometer must

be enabled before this function is called. If the tuple contains

three zero values, the accelerometer is not enabled, not available,

defective, has not returned a reading, or the device is in

free-fall.

.. function:: get_dpi()

Returns the screen density in dots per inch.

.. function:: show_keyboard()

Shows the soft keyboard.

.. function:: hide_keyboard()

Hides the soft keyboard.

android_mixer

.. module:: android_mixer

The android_mixer module contains a subset of the functionality in found

in the `pygame.mixer <http://www.pygame.org/docs/ref/mixer.html>`_ module. It's

intended to be imported as an alternative to pygame.mixer, using code like: ::

Note that if you're using `kivy.core.audio

<http://kivy.org/docs/api-kivy.core.audio.html>`_ module, you don't have to do

anything, all is automatic.

The android_mixer module is a wrapper around the Android MediaPlayer

class. This allows it to take advantage of any hardware acceleration

present, and also eliminates the need to ship codecs as part of an

application.

It has several differences from the pygame mixer:

* The init and pre_init methods work, but are ignored - Android chooses

appropriate setting automatically.

* Only filenames and true file objects can be used - file-like objects

will probably not work.

* Fadeout does not work - it causes a stop to occur.

* Looping is all or nothing, there's no way to choose the number of

loops that occur. For looping to work, the

:func:`android_mixer.periodic` function should be called on a

regular basis.

* Volume control is ignored.

* End events are not implemented.

* The mixer.music object is a class (with static methods on it),

rather than a module. Calling methods like :func:`mixer.music.play`

should work.

.. note::

The android_mixer module hasn't been tested much, and so bugs may be

present.

Hello world example

If you don't know how to start with Python for Android, here is a simple

tutorial for creating an UI using `Kivy <http://kivy.org/>`_, and make an APK

with this project.

.. note::

Don't forget that Python for android is not Kivy only, and you might want

to use other toolkit libraries. When other toolkits will be available, this

documentation will be enhanced.

Let's create a simple Hello world application, with one Label and one Button.

#. Ensure you've correctly installed and configured the project as said in the

:doc:`prerequisites`

#. Create a directory named ``helloworld``::

#. Create a file named ``main.py``, with this content::

#. Go to the ``python-for-android`` directory

#. Create a distribute with kivy::

#. Go to the newly created ``dist-kivy`` distribution::

#. Plug your android device, and ensure you can install development application

#. Build your hello world application in debug mode::

#. Take your device, and start the application!

#. If it's goes wrong, open the logcat by doing::

The final debug APK will be located in ``bin/hello-world-1.0-debug.apk``.

If you want to release your application instead of just making a debug APK, you must:

#. Generate a non-signed APK::

#. Continue by reading http://developer.android.com/guide/publishing/app-signing.html

.. seealso::

`Kivy demos <https://github.com/kivy/kivy/tree/master/examples/demo>`_

You can use them for creating APK too.

- Forum: https://groups.google.com/forum/?hl=fr#!forum/python-android

- Mailing list: python-android@googlegroups.com

helloworld.rst

android.rst

Also, you must configure you're PATH to add the ``android`` binary::