PyInThePhone README
    Copyright (c) 2013 Steve Witham All rights reserved.  
    PyInThePhone is available under a BSD license, whose full text is at:
        https://github.com/switham/pyinthephone/blob/master/LICENSE

PyInThePhone is the beginning of a Python notebook for Android phones and
tablets.  Currently the PyInThePhone project contains three interesting
stabs:
    o  The current working but very simple state of PyInThePhone proper
       in the scripts/ directory (described below).
    o  experiments/boss_worker.py, a command-line program which, unlike
       the current PyInThePhone server, runs Python tasks in a subprocess,
       allowing
           -  gradually-appearing output from long-running tasks
           -  interruption (like control C) from the user.
    o  experiments/ajax.py, based on bottle (instead of my hand-written
       routing and templating code), which serves a demo of a single-page
       app using an ajax call and modifying the DOM in the client.
       
PyInThePhone proper has two parts:
  o  first you start a Python-based web server that will do the work.  
  o  then you go to that server's web page with your browser,
     type paragraphs of Python, and see the resulting outputs.

It would be nice if you could just get the app at the Google store, run
it, and both of the above things would happen.  Instead, PyInThePhone
requires quite a bit of computer-techie tedium (laid out below) to get
going on a phone.  See that and other issues at
    https://github.com/switham/pyinthephone/issues

PyInThePhone was inspired by a talk by Jessica McKellar,
and by iPython, which has a beautiful notebook feature
with matplotlib graphics in the notebook.  (There is someone working on 
getting all the pieces of iPython compiled and working on Android.)

Meanwhile, this prototype-stage project serves an interactive Python
interpreter, from a phone, to the stock browser on the phone.  
The default is to serve on 127.0.0.1 (localhost, loopback), 
only visible within the same device.  But it can also serve 
from one phone to another, from the phone to any computer, and from Unix 
or Mac (not sure about Windows) to the phone.  It also serves its own 
source code so that script changes made in one place can be downloaded 
to another.

For PyInThePhone to work on Android requires SL4A (Scripting Layer for
Android) and PythonForAndroid.  There are instructions for setting 
everything up from scratch and using pyinthephone, below.

For explanation of the code, see the comments in pyinthephone.py.
For usage of the server's options, see the optparse lines near the top of
pyinthephone.py.  A tutorial to set up and run on an Android is below.

scripts/pyinthephone.py is the web server part of pyinthephone.
    It's based on wsgiref.simple_server and the example code at 
        http://docs.python.org/2/library/wsgiref.html
    It does simple template-filling using Python format strings with an 
        html-escaping dict-wrapper.
    Has a "@route()" decorator like in Flask, that does trailing wildcards.
    Has a small amount of code to handle POST inputs.
    Exception tracebacks are shown on the 404 page and in the Python
    interpreter page.  Somewhat insecure if served publicly.

    More features are displayed by browsing to these locations:
    /
    /index.html
    /welcome.html
        Says hello showing full script path, so you can tell for sure 
        whether the server is running in the phone or the computer.
    /faviocon.ico
      	serves	data/SL4A2.jpg.
    /python
        A Python shell like a baby ipython notebook.
        Very insecure when in --public mode.  
	Has a textarea to enter the next set of commands.
        When commands are run they stack up above the textarea with
            light-grey-background text showing the input code,
            white-background text showing stdout/stderr,
            pink-background text showing exceptions or syntax errors.
        All line-wrapped neatly in 80-column background blocks.
        Very basic!  See https://github.com/switham/pyinthephone/issues .
    /environ
      	Prints out the environ dictionary that is passed to @route'd 
        functions.  Although the environ is a subset of the full one,
        showing this is still a little insecure since it still includes 
        info about your system.
    /static/
    /download/
      	Shows a listing of files that you "allowed" on the command line 
        when you started the pyinthephone.py server.
        Each is shown with "view" and "download" links.
    /static/*
        Treat the * part of the path as ./[path/]filename relative to
        where pyinthephone.py is running.  Serve only allowed files.
        Uses mimetypes.guess_type() to set type in response.
        This is where the "view" links go.
    /download/*
      	Same set of files each served as
      	    Content-Type: application/octet-stream
      	    Content-Disposition: attachment; filename="thefilename.ext"
        This has been tweaked to get my phone to download files.
        Right now the phone accepts .txt, .zip and .jpg files at least.
        Python files are served as .py.txt.

    About downloading to Android devices, see also:
       http://www.digiblog.de/2011/04/android-and-the-download-file-headers

Running on SL4A on an Android device:

    These instructions assume you know something about Unix directories 
    (psst, your Android device is a Linux machine), cd, pwd, ls and mkdir,
    and that you know how to clone a git repository into a working
    directory on your computer.

    First go to https://code.google.com/p/android-scripting/
    to download SL4A itself onto your Android.  Then go to
    https://code.google.com/p/android-scripting/downloads
    and download PythonForAndroid_r4.apk .

    As I recall it tries to install once you download it, but you have
    to say yes.

    Assuming you have an SD card, SL4A will create the directory
        /mnt/sdcard/sl4a
    or for some people
        /sdcard/sl4a
    we will call that directory "...sdcard/sl4a" here.
  
    Get Python running.  See the SL4A and Python for Android pages for
    help.  Run one of the Python demos.  Find out how to run the Python 
    interpreter and try a couple commands.  Find out how to quit the
    Python interpreter (back, back, yes).  Find out how to get back to
    the list of scripts (leave and restart SL4A).

Get pyinthephone.py installed on your computer:
    This is necessary to serve the source code to the Android device.
    Use git to clone a pyinthephone working directory from here.
    This will create these things under pyinthephone:
        .git/ (possibly invisible) of course.
        .gitignore
        README
        data/
        scripts/

Prepare the data directory on the Android:
    You can use the bash interpreter in SL4A, or an app like the free File
    Browser, to create the directory
        ...sdcard/sl4a/data
    There should already be
        ...sdcard/sl4a/scripts

Now serve the source from your computer for download to the Android.
    You need to have the computer and Android on the same local net.
    Preferably a home net that strangers aren't sharing, although mainly
    all we are doing is serving some source files right now.
    On the computer, 
        cd pyinthephone  
        scripts/pyinthephone_files.py
    This should say something like
        Serving on host/port 192.168.1.123:8000
    If instead it says
        Serving on host/port 0.0.0.0:8000
    then you need to find the I.P. address of the computer and substitute
    in for the zeros.

Once that server is running, download to the Android
    Start the Android Browser.
    Go to, e.g., http://192.168.1.123:8000 -- the address you found above.
    You should see a "Welcome to the script at ..." message.

    WHAT A PAIN.  I'm sorry the following tedium.  I'm spelling it all out
    assuming any of the mechanics could be unfamiliar to a reader.
    #1 "Make it easy to install."

    Above "Welcome" is "home   environ   files" -- click "files."
    Now you should see "Files available here" and a list.  Each file
    has "view" and "download" links.  
    Click the download link of the first file.  A message should show.
    Also a down-arrow icon in the alerts area at the top of the screen.
    Open the alerts and make sure it says "download completed."
    Sometimes I get "download unsuccessful" on the first download I try.
    In either case dismiss the message (red-circle minus sign), they pile up fast.
    If you get unsuccess, go back and try the same download link again.
    Download all the files and check that they all succeed.

    Now, either with the sl4a bash interpreter, or with File Browser, 
    we need to move the downloaded files to the right places.
    My Browser puts downloaded files in 
        ...sdcard/download
    I will give the instructions for using File Browser to move and
    rename the files; Unix speakers, please translate to shell commands...
    Navigate to ...sdcard/download
    The files you should see (this list will surely change) are
        SL4A2.jpg
        makeargv.py.txt
        pyinthephone_files.py.txt
        pyinthephone_private.py.txt
        pyinthephone_public.py.txt
        pyinthephone.py.txt
    SL4A2.jpg is the only file that goes to ...sdcard/sl4a/data.
    TO MOVE A FILE:
        Press and hold on the file name.
        Menu comes up, pick "Move."
        Navigate over to the data directory.  From ...sdcard/download:
            back button to ...sdcard
            (scroll and) click sl4a
            click data
        Click the menu button, pick "Paste".
    Now go back to downloads for another file (back, back,
    download).  I recommend moving them all first, then delete existing 
    copies if any, then renaming them all from .py.txt to .py.
    The Python files all go to the ...sdcard/sl4a/scripts directory.

Stop the server on your computer.
    ^ C  Sometimes more than once.  Till you see a prompt.
    This makes sure that what you see from this point on is coming out of
    your android itself.

Start the server in private mode on the Android.
    Start SL4A.  You see the list of scripts.
    Pick pyinthephone_private.py   You should get the black screen saying
        dlopen libpython2.6.s0
        Serving on host:port 127.0.0.1:8000
    Now, you want to leave that running and go to the browser.  Careful:
    Press the home button, not the back button.
    You should notice the little green SL4A icon at the top of the screen,
    indicating a running SL4A process.

Access the Android's server via the Android's browser:
    Go to your browser.  Type the address
        http://127.0.0.1:8000
    You should get the Welcome screen with four links at the top:
        home   environ   files   python
    Also notice that the path of the script is in ...sdcard/sl4a/scripts.
    If you click "python," you get the Python interpreter screen with
    a suggested command in a text-entry box.  Click the "run" button and 
    you see both the command with a gray background and the resulting 
    output on a white background.  (You may have to scroll back to see
    it--working on that! #17 )
    The text entry box accepts multiple lines of text, including indented
    loops, function and class definitions, and so forth.  
    Globals, imports and definitions persist between entries.
    Currently you can't edit a block you finished 
        #20
    but you can copy a whole block, paste it into the text-entry area and edit that.

To stop the server and/or Python interpreter on the Android:
    Pull down the alerts from the top of the screen.
    One of them says, "SL4A Service, tap to view 1 running script."
    Click it, you see a little status monitor.
    TO SIMPLY STOP IT:
        Click and hold the entry for pyinthephone_private.py.
        Up pops a single choice: Stop -- click that.
    TO SEE THE SERVER LOG THEN STOP IT:
        Click the entry for pyinthephone_private.py.
        You see the http server log for the things you did on the web
        pages and Python interpreter page.
        To stop the process, click back, back, and yes to confirm.
        To leave it running, click the home button.

The server options on Android
    The server has three important options:
        Whether to serve to devices other than itself ("public"), 
            default: no, use the private 127.0.0.1 IP address.
        Whether to serve the Python interpreter, default: no.
        What files, if any, to serve, default: none.
    On Android (SL4A), these options are controlled by which script is run:
        Script                      public?  python?  serve what files?
        pyinthephone.py                no       no        none
        pyinthephone_private.py        no      yes    all pyinthephone source
        pyinthephone_files.py         yes       no    all pyinthephone source
        pyinthephone_public.py        yes      yes    all pyinthephone source

    Needless to say, the last option is the least secure on a public net.
    On your own private net, it lets you use the computer's keyboard and 
    screen to run Python commands on your Android (next section).

Serving to the public from the Android
    If you run either of the "public"-serving scripts, and if you haven't
    rooted your phone and hacked SL4A, then the server says,
        Serving on host:port 0.0.0.0:8000
    Which means you need to find out the Android's IP address for another
    machine to access it.  The way to find that manually is this:
    Press the home button => Settings => Wireless and network settings
    => Wi-Fi settings => menu key => Advanced, and there you will see
    the IP address.  (This is on Android 2.3.7.)
    
    All the programmatic ways I know to find the IP address don't work 
    (they seem deliberately disabled) in SL4A in either Python or bash.
    Any help with that would be appreciated.  The solution is probably
    to make an Android package with the right permissions, 
        #12

    If the Wi-Fi control panel doesn't work, another method is to run
    pyinthephone.py --public  on another computer, browse to it from the 
    Android, and look at the client IP in the server log that prints 
    on the computer screen.

 -end-