Fun2Code

Changing the PirateBox Location

2012-01-26T01:58:00.000-08:00

This post gives a quick overview what has to be done to move the PirateBox installation to a different directory.

By default the PirateBox HTML files are located in the directory /sdcard/paw/html/app/plugins/piratebox_plugin/html and uploaded files are stored in the folder uploads inside the HTML directory.

I'll demonstrate what to do to move the PirateBox to a different directory (in my example /sdcard/piratebox_ext). You can of course also use a directory on an external SD card.

Copying the HTML Directory
First thing to do ist to create the new folder /sdcard/pireatebox_ext.
Now copy the directory /sdcard/paw/html/app/plugins/piratebox_plugin/html to the new location /sdcard/pireatebox_ext.

As a next step we will edit the PAW server configuration.

Changing the PAW Configuration
The configuration file used for PirateBox is named handlers.xml and it's located inside the /sdcard/paw/html/app/plugins/piratebox_plugin/conf directory.
Edit this file and replace each occurence of /sdcard/paw/html/app/plugins/piratebox_plugin with /sdcard/piraebox_ext.

Changing the Web Pages
Last step to do is to edit the files list.xhtml and pb.xhtml inside the /sdcard/piratebox_ext/html directory.
In each file there is one line that defines the upload directory.
Again, change each occurence of /sdcard/paw/html/app/plugins/piratebox_plugin to /sdcard/piraebox_ext.

That's it ... on next startup the new PirateBox location should be used.

NFC - NDEF Support

2011-12-22T03:16:00.000-08:00

NDEF messages are the standard way to write information to NFC tags on Android.
The latest version of PAW (0.84) has support for text, URI, smart poster and mime media NDEF messages.
The classes and their methods are described in the PAW Functions documentation within the PAW web application.
NFC support is now also available in PAW Runtime.
To show how the new functionality can be used (and to give you the possibility to play with NFC tags), a NFC reader/writer plugin is available for PAW. This plugin is also available in the newest add-on package for PAW Runtime.

Here are some screenshots...

Plugin

NFC Plugin

Plugin requesting NFC Tag

Runtime

PAW Runtime with NFC Reader/Writer

Runtime version

This will be the last update of PAW this year and possibly the last blog entry.
To all of you ... Merry Christmas and a Happy New Year :)

ICS: Getting NFC Tags to Work

2011-12-15T10:24:00.000-08:00

Since December I'm a happy owner of a Galaxy Nexus :)
NFC seemed like an interesting thing, so I started to integrate NFC support into PAW.

First thing I did was to order some Mifare Classic 1K tags from tagsfordroid.com.
They arrived fairly quickly and delivery was free of charge.

NFC Tags

To try things out I installed a lot of NFC reader and writer apps. To my dismay none of them seemed to work.
They could read the tags but could not write them. Having no idea how NFC worked, I was fairly disappointed :(

Searching the web I found out that this seems to be a bug in ICS:
http://code.google.com/p/android/issues/detail?id=22258

Googles sais that there will be a fix provided, but when, no one can tell.
So I tried to get it working myself...

If you would like to test the things below, install the latest PAW version (0.80) from the Android Market.

Disclaimer:
This solution is only working for Mifare Classic 1K tags!
If you try as described you do it at your own risk!
It's not my fault if your tags do not work afterwards!

Read the updates at the end of the post first!

The Problem
The problem (as reported in the bug report) seems to be that the tech reported by the tag do not contain
android.nfc.tech.Ndef which is necessary to write NDEF messages.

You can try this with the following code that you can insert into the BenShell Console of the PAW web application:

import de.fun2code.android.pawserver.AndroidInterface;
import android.nfc.NfcAdapter;

intent = AndroidInterface.getNfcIntent(5); // 5 secs timeout
if(intent != null) {
  tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
  print(tag);
}
else {
  print("No Tag found!");
}

If the result is TAG: Tech [android.nfc.tech.MifareClassic, android.nfc.tech.NfcA] writing NDEF messages will not work!

The Possible Fix
As mentioned above I have no expirience with NFC, so I tried to find a solution that worked without having to know NFC or the Mifare tags in detail.

I searched the web and found some Mifare Classic 1K dumps at the nfc-tools site.
After downloading a dump I tried to write it to the tag. Interesting enough it seemd to work :)

After writing the dump, the above script reported:

TAG: Tech [android.nfc.tech.MifareClassic, android.nfc.tech.NfcA, android.nfc.tech.Ndef]

So here are the step by step instructions:

Download the dump file from the nfc-tools site: mfc_1k__url_nfc-tools.mfd
Save the dump file to the /sdcard of your android device.
Start PAW and open the BeanShell console.

Copy/paste the following script into the console:

/*
Mifare Classic - Write dump
*/
import de.fun2code.android.pawserver.AndroidInterface;
import android.nfc.NfcAdapter;
import android.nfc.NdefRecord;
import android.nfc.NdefMessage;
import android.nfc.tech.*;
import android.os.Bundle;


intent = AndroidInterface.getNfcIntent(5); // 5 secs timeout
print(intent);
if(intent != null) {
  tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
  print(tag);
  
  if(nfc != null) {
      nfc = MifareClassic.get(tag);
      nfc.connect();
    print("Is connected: " + nfc.isConnected());

  
     fis = new FileInputStream("/sdcard/mfc_1k__url_nfc-tools.mfd");
     
     b = new byte[16];

     errors = 0;
    
    sectors = nfc.getSectorCount();
    blocksPerSector = nfc.getBlockCountInSector(0);
    
    for(sector=0; sector<sectors; sector++) {
      print("Sector " + sector);
      
      for(block=0; block < blocksPerSector; block++) {
        logicBlock = nfc.sectorToBlock(sector) + block;
        $$.print("  Block: " + block + " ... ");

        fis.read(b);

        if(sector == 0 && block == 0) {
           print("Manufacturer block ... skipped");
           continue;
        }

        try {
          nfc.authenticateSectorWithKeyA(sector, MifareClassic.KEY_DEFAULT);
          nfc.writeBlock(logicBlock, b);
          print("ok");
        }
        catch(e) {
            print("error");
            errors++;
        }
      }
    }
    
    fis.close();
    nfc.close();
      print("--------------------------------------------------------------------------");
      print("Errors: " + errors);
      print("Dump written!");
   }
   else {
      print("Tag not supported!");
   }

}
else {
  print("No Tag found!");
}

Start the script and as soon as the PAW app is in foreground, place the tag at the back of the phone and leaf it there until the script is finished.

After that the tag is hopefully working.

Good luck and happy hacking :)

Update:
Ndef.getMaxSize() returns only 92 bytes that can be written to a NDEF message. I don't think that's normal :(

You can check this yourself with the following code:

import de.fun2code.android.pawserver.AndroidInterface;
import android.nfc.NfcAdapter;
import android.nfc.tech.Ndef;
 
intent = AndroidInterface.getNfcIntent(5); // 5 secs timeout
if(intent != null) {
  tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
  print("Max NDEF message size: " + Ndef.get(tag).getMaxSize() + " bytes");
}
else {
  print("No Tag found!");
}

Update 2:
The latest NFC TagWriter by NXP is able to format unformatted tags and fixes the problem.
Here is the Android Market link: NFC TagWriter by NXP

PirateBox on Android

2011-12-01T08:30:00.000-08:00

A while ago psundegroud created the thread [TUT]Roll Your Own PirateBox! PirateBoxMobile. At that time my only rooted device was an old Samsung Galaxy I7500 running Android 1.6. We managed to get this working. The two main issues were that WiFi Tether was needed, which didn't run on all Android devices and that only Ad-Hoc mode was available. The missing Infrastructure mode prevented most Androids from seeing the PirateBox hotspot.

Meanwhile I have a rooted Notion Ink Adam running AdamComb v0.3. So I tried to get PirateBox running by using the built in tether app. Built in tethering uses Infrastructure mode, which solves above mentioned problem.

On my Adam this is really working fine and I hope that it will also run on other Android units.
I'll divide the post in two parts. The first part describes the technical details, so if someone has problems in getting this to work this might be helpful for further testing.

Along with setting up the scripts I have also written a plugin for PAW which should make setup really easy.
If you are not interested in the technical details you can right jump to the Installing the Plugin section.

Techical Details

Setting up the PirateBox during boot is done by PAW startup scripts.

The main tasks of these scripts are:

Killing dnsmasq and restarting it with changed parameters, so that DNS requests always respond with the IP of the Android device.
Configuring iptables so that requests to port 80 are redirected to the port PAW is listening on, because PAW can not operate on privileged ports.
Change the PAW configuration to use the PirateBox Handler, which ensures that all unknown request are forwarded to the base URL (piratebox.org/).

The startup scripts are located in the subfolders 0 and 1 of the directory /sdcard/paw/etc/init. These folders represent PAW runlevels. Runlevel 0 is before the server starts and after server shutdown and 1 is after server start and before the server shuts down. Scripts beginning with S_ will be called on startup and scripts starting with K_ will be run at shutdown.

So here is a short summary what these scripts are doing.

0/S_PirateBox.bsh:

Checks if tethering is running. If not none of the steps below will be performed.
Kills the "original" dnsmasq process and starts a new one.
Executesiptables commands to get port redirection working.
Replaces the original PAW configuration with the PirateBox configuration.

1/S_SpirateBox.bsh:

Checks if tethering is running. If not none of the steps below will be performed.
Restores the original PAW configuration.
Displays a PirateBox notification.
Sets the max upload limit to 200MB.

1/K_S_SpirateBox.bsh:

Clears the PirateBox notification.
Kills dnsmasq process.
Stops tetherig and restarts WiFi.

0/K_S_SpirateBox.bsh:

Removes iptables rules for port redirection.

If you run into problems have a look at these scripts and try to run the commands inside the scripts individually.

Installing the Plugin

PAW Plug-in Menu

Installing the plugin is easy. I've put it on the PAW plugin page, so you'll find it within the PAW web application or you can direct download it from the PAW Plugin Page.
After download extract the ZIP file to the /sdcard/paw/html/app/plugins directory of your Android device.
Now after re-entering the PAW web application, the PirateBox plugin should be visible in the Plugins menu.

If the plugin setup screen shows a warning in red, the installation is likely to fail, because some prerequisites are missing.
If no warnings are displayed, press the Install button. You can also try to setup a PirateBox Access Point (AP) automatically. I'm not sure, if this is working on all devices. If it's not working, please create an AP manually.
To uninstall the plugin, press the Uninstall button.

PirateBox Plugin

It is important to note, that PirateBox will only be started if tethering is active before PAW starts up.
Otherwise the normal PAW configuration will be applied. So you can choose between these two configurations.

I hope that's not just working on my Adam but on many other devices as well.

Screenshost
Here are some screenshots from my setup...

PirateBox Startup

Connected to PirateBox

PirateBox on Nexus One

PirateBox in Chromium

Video

Here is a video that shows the PirateBox in action...

Update

Since version 0.3 of the plugin, PirateBox is also working on rooted Galaxy Nexus devices running Ice Cream Sandwich.
Here is a video...

Running PAW on Port 80

2011-11-24T23:57:00.000-08:00

PAW is only running on ports above 1023, because restricted ports are not permitted for normal apps.
For root users there is a solution by using iptables via the Superuser app.

I'm not sure if the below mentioned solution is working on all rooted devices.
Here is my configuration: Notion Ink Adam running AdamComb v0.3

If this works for you can easily be tested by copying the below code into the BeanShell Console of the PAW web application:

import de.fun2code.android.pawserver.util.*;

execRootShell(String[] commands) {
  shellCmd = "su -c sh";

  sh = Runtime.getRuntime().exec(shellCmd);
  os = sh.getOutputStream();

  for(cmd : commands) {
    os.write((cmd + "\n").getBytes());
  }

  os.write(("exit\n").getBytes());
  os.flush();
  sh.waitFor();  
}

/* ---- Config -------- */
ip = Utils.getLocalIpAddress();
redirectFrom = 80;
redirectTo = 8080;
action = "ADD"; // Can be ADD or DELETE
/* -------------------- */

action = "-" + action.substring(0, 1);

String[] iptablesCmds = new String[] {
  "iptables -t nat " + action + " OUTPUT -d 127.0.0.1 -p tcp --dport " + redirectFrom + " -j REDIRECT --to-ports " + redirectTo,
  "iptables -t nat " + action + " OUTPUT -d " + ip + " -p tcp --dport " + redirectFrom + " -j REDIRECT --to-ports " + redirectTo,
  "iptables -t nat " + action + " PREROUTING -d " + ip + " -p tcp --dport " + redirectFrom + " -j REDIRECT --to-ports " + redirectTo
};

execRootShell(iptablesCmds);

After executing the code, PAW should respond to requests on port 80.
If not, this solution seems not to be working on your configuration.

To forward port 8080 to port 80 every time PAW starts up, create a file called S_forward.bsh inside the /sdcard/paw/etc/init/0 directory.
In order to stop the forwarding when the PAW service shuts down, create an additinal file called K_forward.bsh and copy the same code.
You only have to change the line action = "ADD"; to action = "DELETE"; to stop the forwarding.

Hope that's not just working on the Adam...

PHP Plug-in Update

2011-11-24T01:46:00.000-08:00

My cross compiled version of the PHP CGI was not working so well and I didn't manage to fix it.

Fortunately Klaas Biker informed my that Iulian Virtejanu has cross compiled a PHP CGI version that seems to work significantly better.
Here is Iulian's blog entry: PHP and Lighttpd for Android

Iulian gave me the permission to use it in PAW, so I have updated the PHP Plug-in to version 0.3.

There is one known issue:

system(...) does not work.
It is because system('pwd') actually invokes a hardcoded /bin/sh -c 'pwd' - and /bin/sh is not available on Android.
Iulian has submitted a bug report to PHP: https://bugs.php.net/bug.php?id=60081

If you find more bugs, please let me know. I will forward them.

Building PHP from Scratch

2011-10-31T02:05:00.000-07:00

This post by Rahul Amaram describes how to build PHP for Android from scratch and how it can later be used within PAW.
I've added links to the needed files at the end of the post.

Thanks to Rahul for putting this together!

Here is Rahul's documentation...

It is suggested to use a VM for compilation so that you can take snapshots at regular intervals. Also as per google recommendation, it is suggested to use a VM with at least 8 GB RAM/swap and 12 GB of free hard disk.

Install Ubuntu 10.04 64-bit (select username as "joschi") on a VM.

After booting ubuntu, login as joschi.

Download and extract android-php

$ cd
$ wget -c "http://paw-android.fun2code.de/download/android-php.zip"
$ sudo apt-get install unzip
$ unzip android-php.zip

First initialize build environment. For donut, java 5 is needed. Also compiling with gcc/g++ 4.4 was throwing errors during compilation. Therefore we use gcc/g++ 4.3 for compilation.

$ sudo apt-get install python-software-properties
$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu hardy main multiverse"
$ sudo add-apt-repository "deb http://archive.ubuntu.com/ubuntu hardy-updates main multiverse"
$ sudo apt-get update
$ sudo apt-get install sun-java5-jdk

$ sudo apt-get install git-core gnupg flex bison gperf build-essential \
zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \
x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \
libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown \
libxml2-utils

$ sudo apt-get install g++-4.3-multilib

Download Android source
This will be about 3 GB.

$ mkdir ~/bin
$ PATH=~/bin:$PATH
$ curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
$ chmod a+x ~/bin/repo

$ mkdir ~/android-donut-src
$ cd ~/android-donut-src
$ repo init -u https://android.googlesource.com/platform/manifest -b android-1.6_r2
$ repo sync

It is a good idea to take snapshot of the VM here.

Build Android

$ cd /usr/bin
$ sudo ln -sf cpp-4.3 cpp
$ sudo ln -sf g++-4.3 g++
$ sudo ln -sf gcc-4.3 gcc
$ sudo ln -sf gcov-4.3 gcov
$ sudo ln -sf cpp-4.3 x86_64-linux-gnu-cpp
$ sudo ln -sf g++-4.3 x86_64-linux-gnu-g++
$ sudo ln -sf gcc-4.3 x86_64-linux-gnu-gcc

$ cd ~/android-donut-src
$ source build/envsetup.sh
$ lunch generic-eng
$ make -j4

It is a good idea to take another snapshot of the VM here.

Next build android-php. The patch is applied in order to avoid the error "undefined reference to `__sync_fetch_and_add_4'" during compilation.

$ cd ~/android-php
$ rm -rf ~/android-donut-src/bionic/libc/include/
$ unzip -d ~/android-donut-src/bionic/libc/ bionic_libc_include.zip
$ patch php-5.3.6/ext/standard/php_crypt_r.c < ~/sync_fetch_and_add.patch
$ ./build_php_5.3.sh

Finally copy php-5.3.6/sapi/cgi/php-cgi to /mnt/sdcard/paw/html/app/plugins/php_plugin/bin/ on your android phone (be sure to backup the existing php-cgi file), and install PHP using the PAW Web App.

References:

Files:
android-php.zip
sync_fetch_and_add.patch

Setting up a Cloud Print Printer using the Cloud-X API

2011-10-19T08:35:00.000-07:00

The Cloud-X Java API makes it easy to set up a Google Cloud Print aware printer. In the latest API version Cloud Print push notifications are supported.

The below sample code shows the registration of a new printer (if not already present) and how to listen to push notifications.
For the sake of simplicity this is straight forward code, so there might be cleaner ways to do is ;)

Here is the sample code with comments:

/*
  * Process print job
  */
 public static void processJobs(CloudPrintConnection gcp, Printer printer) {
  try {
   List<Job> jobs = gcp.fetch(printer);
   if (jobs != null) {
    for (Job job : jobs) {
     System.out.println("Processing job " + job.getId() + " ("
       + job.getTitle() + ")");
     gcp.deletJob(job);
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public static void main(String[] args) {
  try {
   String printProxy = "testprinter-" + NetworkUtil.getMacAddress();

   /*
    * Our printer
    */
   final Printer printer = new Printer();
   printer.setProxy(printProxy);
   printer.setName("Test Printer");
   printer.setStatus("Online");

   final CloudPrintConnection gcp = new CloudPrintConnection();
   gcp.connect(username, password, "cloudprint",
     "Cloud Print Test Client", null);

   /*
    * Register printer if not already present
    */
   List<Printer> printers = gcp.list(printProxy);
   if (printers.size() == 0) {
    System.out.println("Registering Printer with Proxy "
      + printProxy);
    gcp.register(printer, null);
   } else {
    printer.setId(printers.get(0).getId());
   }

   /*
    * Refetch all printer info
    */
   gcp.printer(printer);

   System.out.println("Printer Name: " + printer.getName());
   System.out.println("Printer ID: " + printer.getId());
   System.out.println("---------------------------------------------");

   processJobs(gcp, printer);

   /*
    * Wait for push notifications
    */
   PushReceiver pr = new PushReceiver("Cloud-X API - Push Receiver");
   pr.addListener(new PushListener() {

    @Override
    public void onReceive(String printerId) {
     if (printerId.equals(printer.getId())) {
      processJobs(gcp, printer);
     }
    }

    @Override
    public void onConnect() {
      System.out.println("Connected to Google Talk!");
    }

    @Override
    public void onDisconnect() {
      // Do nothing
    }
   });

   pr.connectPlain(username, password);

  } catch (Exception e) {
   e.printStackTrace();
  }

 }

Cloud-X - Sharing Files through the Cloud

2011-10-13T00:02:00.000-07:00

We just released the first alpha version of Cloud-X.
Cloud-X uses Google Cloud Print to share files between different users and devices. Along with the PC and Android app the Java API to access Google Cloud Print is also released.

This is a very early version, so there might be bugs.
The Android app and an online and stand alone PC version can be found at the following site:
http://cloud-x.fun2code.de

Comments welcome!

PAW and DynDNS

2011-09-19T07:11:00.000-07:00

From time to time I get requests from users who would like to have a DynDNS integration into PAW.
I thought about it ... but it just doesn't make much sense, because there are enough apps in the Android Market that do exactly this.
So I will not provide a plug-in or another means of DynDNS integration, but for those of you who would like to experiment here is a basic BeanShell implementation of the DynDNS API:

import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.*;
import org.apache.http.client.methods.*;
import org.apache.http.util.*;
import org.apache.http.auth.*;

/*
    Host, username and password settings
*/
hostname = "";
user = "";
password = "";

/*
    Get IP number
*/
client = new DefaultHttpClient();  
getURL = "http://checkip.dyndns.com/";
get = new HttpGet(getURL);
responseGet = client.execute(get);  
resEntityGet = responseGet.getEntity();

if (resEntityGet != null) {
  // Extract IP number
  ip = EntityUtils.toString(resEntityGet).replaceAll(".*?([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}).*", "$1").replaceAll("[\n\r]", "");
  print("IP: " + ip);
 
 /*
    Send DynDNS update request
 */
  updateURL= "https://members.dyndns.org/nic/update?hostname=" + hostname + "&myip=" + ip + "&wildcard=NOCHG&mx=NOCHG&backmx=NOCHG";
  get = new HttpGet(updateURL);
  client.getCredentialsProvider().setCredentials(new AuthScope(null, -1),
new UsernamePasswordCredentials(user, password));
  responseGet = client.execute(get);  
  resEntityGet = responseGet.getEntity();
  
  response = EntityUtils.toString(resEntityGet);
  success = response.startsWith("good");
  
  // Print result
  print("Response: " + response);
}

Hostname, username and password have to be inserted into the script.

This implementation is not complete but should be a good start for further development.
To start the script automatically when PAW starts, put it in the paw/autostart or paw/etc/rc.* folder.

The API is quite easy and it should not take too long to get a complete implementation up and running ...

PAW and DavDrive on Google TV

2011-09-15T21:31:00.000-07:00

So now that the Google TV emulator is out and my Linux box supports KVM I tried PAW and DavDrive.

The only problem I had was that /sdcard was mounted read only and thus PAW could not extract its content and DavDrive could not write files.
To solve this issue I opened an ADB Shell and remounted the root file system via mount -o remount,rw /.

Aport from that everything worked fine. Compared to the Honeycomb emulation the Google TV emulation was quite fast.

Below are screen-shots of the two apps running on Google TV.

PAW running on Goolge TV

DavDrive running on Google TV

PAW - I18N & Native Mapper

2011-08-31T12:14:00.000-07:00

It might seem that there is no process concerning PAW, but actually I'm quite busy :)
My plans are to release a 1.0 version this year. In October PAW will be two years under development and I think it's time to leave beta.

Things I'm currently working on are internationalization and what I call Native Mapping.

Internationalization
Currently I'm translating the web interface into German. This will result in a Java properties file with key and value pairs.
After this is finished it should be quite easy to make a translation for any language.
Translation takes much longer than I thought and I'm sure there will be a lot of mistakes in the first version.

Native Mapper
The PAW BeanShell approach has the advantage of being very flexible but when it comes to performance it's really slow.
As I showed in a previous blog post BeanShell is considerably slower than the same native code.
The Native Mapper is an approach to solve this dilemma.

The Mapper is comparable to a Servlet mapping in a JEE environment. The Native Mapper is implemented as Brazil Handler that sits in front of the BeanShell Handler and redirects URLs to native code (DEXed classes).

Handler Chain

The next version of PAW will use the mapper to speed up the generation of graphics inside the web application. This includes the generation of icons, contact images, album covers and the load graph.
Because some versions of HoneyComb have the problem that the DEX classloader is not working the original BeanShell code is also available. So if the Native Mapper fails to initialize (because the DEX classes are not available), the old BeanShell code is used.

A good example to show the possible speed-up when the Native Mapper is used is the Installed Apps page of the web application. On my Nexus One it shows 131 icons. Without Native Mapper this takes 90 seconds, with Native Mapper only 10.

Speed Test (time in seconds)

I hope to release the new version in the next couple of weeks ... stay tuned :)

DavDrive - Litmus Compliance Test

2011-07-18T09:56:00.000-07:00

DavDrive works reasonably well with Linux, Mac and Windows clients. To make DavDrive more RFC 2518 compliant the Litmus compliance test was used.
Litmus contains a variety of tests. Because DavDrive implements only a subset of the RFC specification only three tests are relevant: basic, copymove and http

Litmus Test Results (left DavDrive 1.40, right DavDrive 1.41)

The upcoming DavDrive version 1.41 passes all three tests without failure.
This involved a significant code change, so intensive testing is necessary before publishing the new version.

PAW - Dynamic Handlers and Filters

2011-07-12T13:00:00.000-07:00

In addition to dynamically loading DEXed classes the latest PAW version provides the possibility to use external so called dynamic Handlers and Filters.

Handlers and Filters are components of the underlying Brazil framework. Handlers are responsible for handling HTTP request. Filters in addition can process the output provided by an handler. In principle PAW consists of a number of handlers that are called in a row until a Handler feels responsible to handle the request.
There is a special Handler, the so called FilterHandler. This Handler can wrap a Handler and directs the output of that Handler to a list of Filters which process the response before it is provided to a Web Browser.

I'll demonstrate this on a small but useful filter that stamps all images inside a defined directory with the PAW logo. Such a technique is often used on sites that provide screenshots and want to automatically decorate them with a logo.

Image without and with Filter applied.

Note:
In this example only the AndroidDynamicFilter is used. There is also a AndroidDynamicHandler available which can be used if a custom Handler is needed. For this example the AndroidDynamicHandler class is not needed.

Note on Honeycomb: As mentioned in an earlier post, this might not work on Android 3.x because of a bug in Honeycomb.

Prerequisites

What you will need to build the Filter:

Creating a Java Project

When Eclipse is running, we can create a standard Java project.
The Java build path should include the brazil.jar (I've renamed it from brazil-2.3.jar to brazil.jar) and the android.jar file. The android.jar files can be found in the installation directory of the Android SDK (platforms/android-*).

Java Build Path

The Filter Class

After creating the project create a source folder (if not available) and create a new package called dextest.filter.
Inside that package we will create the StampFilter class.

The structure should look something like this:

Project Structure

Before creating the StampFilter class just a view words how a filter works.
A Filter has three important methods:

init() - This initializes the Filter and is called on Filter startup (when PAW starts). This returns true on success and false on failure.
shouldFilter() - Is called on each Handler output and decides weather the response is to be filtered or not. Returns true if the filter() method should be called, false otherwise.
filter() - This is the actual filter method. It processes the content form the Handler and returns it.

Below is the code of the Filter class:

package dextest.filter;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;

import sunlabs.brazil.filter.Filter;
import sunlabs.brazil.server.Request;
import sunlabs.brazil.server.Server;
import sunlabs.brazil.util.http.MimeHeaders;

public class StampFilter implements Filter {
 private String prefix;

 private static final String STAMP_FILE = "stampFile";

 private static final String IMAGE_DIRECTORY_URL = "imageDirctoryUrl";

 private String stampFile;
 private String imageDirectoryUrl;

 public boolean init(Server server, String prefix) {
  this.prefix = prefix;

  Properties props = server.props;

  stampFile = props.getProperty(prefix + STAMP_FILE, null);
  imageDirectoryUrl = props.getProperty(prefix + IMAGE_DIRECTORY_URL, null);

  if (stampFile != null && imageDirectoryUrl != null) {
   if (!new File(stampFile).exists()) {
    server.log(Server.LOG_ERROR, prefix, STAMP_FILE
      + " does not exist!");
    return false;
   }

   if (!new File(imageDirectoryUrl).isDirectory()) {
    server.log(Server.LOG_ERROR, prefix, IMAGE_DIRECTORY_URL
      + " is not a directory!");
    return false;
   }

   return true;
  } else {
   server.log(Server.LOG_ERROR, prefix, "Missing parameter(s)");
   return false;
  }
 }

 public boolean shouldFilter(Request request, MimeHeaders headers) {
  String type = headers.get("Content-Type");
  return type != null && type.startsWith("image/png") && new File(request.url).getParent().equals(imageDirectoryUrl);
 }

 public byte[] filter(Request request, MimeHeaders headers, byte[] content) {
  try {
   return stampImage(content);
  }
  catch(Exception e) {
   request.log(Server.LOG_ERROR, prefix, "Exception: " + e.getMessage());
   return content;
  }
 }

 /**
  * This is the request object before the content was fetched
  */
 public boolean respond(Request request) throws IOException {
  return false;
 }

 byte[] getImageBytes(String image) throws IOException {
  File f = new File(image);
  byte[] bBitmap = new byte[(int) f.length()];
  FileInputStream fis = new FileInputStream(f);
  fis.read(bBitmap);
  fis.close();
  return bBitmap;
 }

 private byte[] stampImage(byte[] imageBytes) throws IOException {
  byte[] stampBytes = getImageBytes(stampFile);
  Bitmap stampBitmap = BitmapFactory.decodeByteArray(stampBytes, 0, stampBytes.length);

  Bitmap imageBitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length);
  imageBitmap = imageBitmap.copy(imageBitmap.getConfig(), true);

  Canvas canvas = new Canvas(imageBitmap);
  canvas.drawBitmap(stampBitmap, imageBitmap.getWidth() - stampBitmap.getWidth(), imageBitmap.getHeight() - stampBitmap.getHeight(), null);

  ByteArrayOutputStream bos = new ByteArrayOutputStream();
  imageBitmap.compress(Bitmap.CompressFormat.PNG, 0 /*ignored for PNG*/, bos);

  return bos.toByteArray();

 }
}

In the init() method you can see that the Filter excepts two parameters. One is called stampFile, the other imageDirectoryUrl. The stampFile parameter specifies the file (absolute path) of the image that is placed on top of the original image. The imageDirectoryUrl parameter specifies the URL for which the filter is applied.
The init() method does check if the parameters are present and if they are valid. The parameters are read from the configuration by using props.getProperty(). The prefix is basically the name of the Filter.

The shouldFilter() method checks if the file requested is a PNG and if the file is served from the URL that should be filtered.

Filtering is actually done in the filter() method. This method will not be discussed in detail, because it uses standard Android functionality to do the stamping.

After compiling the Filter, create a JAR file called filterTest.jar.

Creating the DEXed Filter JAR

Now we can use the dx command from the Android SDK to create a DEXed JAR file:
./dx --dex --output=/tmp/filterTest_dex.jar --positions=lines filterTest.jar

Now copy the resulting filterTest_dex.jar JAR file over to your Android device and store ist directly on the SD Card (/sdcard).

Here is the ready to use JAR file: filterTest_dex.jar

The Stamp Image

In principle you can use any PNG image for stamping the images.
Here is an example:

Store it directly under /sdcard/paw_powered.png.

Modifying the PAW Configuration

The next step is to modify the PAW configuration. The two important files are handler.xml and filter.xml. Both files are located inside the paw/conf directory.
The handler.xml defines the Handles and the filter.xml defines the Filters used by PAW.
We will start with the filter configuration. For that open the filter.xml file and add the following Filter definition inside the <filters> </filters> tags:

<filter status="active" type="custom">
    <name>Stamp Filter</name>
    <description>Stamp Filter</description>
    <removable>true</removable>
    <id>stamp</id>
    <files />
    <params>
      <param name="stamp.class" value="org.paw.filter.AndroidDynamicFilter" />
      <param name="stamp.filterClass" value="dextest.filter.StampFilter" />
      <param name="stamp.filterJars" value="/sdcard/filterTest_dex.jar" />
      <param name="stamp.stampFile" value="/sdcard/paw_powered.png" />
      <param name="stamp.imageDirctoryUrl" value="/stamp" />
    </params>
  </filter>

PAW knows two filter types httpProxy and custom. HttpProxy filters are only important when PAW is used as a proxy server. In our case the StampFilter is a custom Filter.
The parameters define the Filter class to use, the location of the DEX file, the stamp image and the URL (the directory) where the images that should be stamped are located (we will create hat directory below).

Now comes the Handler part. Our new Handler definition will replace the existing File Handler definition and use the defined StampFilter. So edit the file handle.xml and replace the existing File Handler with the following XML code:

<handler status="active">
    <name>File Handler</name>
    <description></description>
    <removable>true</removable>
    <id>filehandlerWrapper</id>
    <files />
    <params>
      <param name="filehandlerWrapper.class" value="sunlabs.brazil.filter.FilterHandler" />
      <param name="filehandlerWrapper.handler" value="filehandler" />
      <param name="filehandlerWrapper.filters" value="stamp" />

      <param name="filehandler.class" value="sunlabs.brazil.server.FileHandler" />
      <param name="filehandler.root" value="/sdcard/paw/html" />
      <param name="filehandler.defaults" value="index.html" />
    </params>
  </handler>

After that restart the PAW app and let's start testing :)

Using the Filter

For testing, let's create the directory for the images that should be stamped as defined in the Filter definition. For that create a directory called /sdcard/paw/html/stamp and place some PNG images inside it. For a test, you can also put some other image files (e.g. JPG) in that directory. These should not be modified.
Now enter the Url http://<ip number>:8080/stamp into the address bar of your browser and select a PNG image.

The resulting image should include the stamp image in the lower right corner.

PAW - Dynamic DEX Class Loading

2011-07-11T08:08:00.000-07:00

With PAW developers have the possibility to create dynamic pages using BeanSell scripts.
This is nice because pages can be developed very fast. On the downside BeanShell is not the fastest scripting language on the planet due to its heavy use of Java reflection. This was demonstrated in an earlier blog entry where BeanShell code is between 10 and 50 times slower than the native equivalent.

One note beforehand: Dynamic DEX class loading is currently not working on Honeycomb. This is due to a bug in the in the DexClassLaoder. Google has aknowledged the bug. This bug should be fixed in upcoming Honeycomb releases.

PAW now introduces a new directory called webconf/dex wich can contain JAR and APK files in DEX format. On server startup all files which are present in hat directory will be added to a new classloader. This classloader can be retrieved by calling getDexClassloader() on the service object. To make life easier the command useDexClasses() can be used in BeanShell pages.

To convert an existing JAR file into a DEXed one the following dex command from the Android SDK (normally located in the platform-tools directory) can be used:
./dx --dex --output=output.jar --positions=lines input.jar

If you would like to keep the existing classes inside the JAR file, the additional option --keep-classes can be used. With this option the same JAR file can be used on Android or a PC running standard Java.

After the DEXed JAR file has been created it can be copied to the webconf/dex folder of the PAW installation.

Now to use the new classes you can either restart PAW or issue the following command from the BeanShell Console:

server.props.get("serviceContext").buildDexClassLoader();

If the new classes should be used inside a BeanShell XHTML page the following command has to be executed:

useDexClasses()

That basically tells BeanShell to use the new classloader.

Example

Here is a very simple Java class that sums up two Intergers:

package dextest;

public class Math {
 public static int sum(int i, int j) {
  return i + j;
 }
}

After expopting the class as JAR file it can be converted into DEXed format using the following command (the JAR file dextest.jar is located in the /tmp directory) :
./dx --dex --output=/tmp/dextest_dex.jar --positions=lines dextest.jar

The resulting dextest_dex.jar JAR file is now placed inside the webconf/dex folder and PAW is restarted.

Now we can use the new class within the BeanShell Console like this:

useDexClasses();

import dextest.Math; 

print(Math.sum(1, 3));

Windows Performance and Filesize Limit

2011-06-06T08:32:00.000-07:00

This weekend I had the chance to test DavDrive's performance when running Widows 7 (32bit).
I tested with Windows Explorer and BitKinex. The latter gave me a nice performance graph. My test file was a video file that was approx. 900MB in size.
The first things I notices was that Windows 7 seems to have a file size limit when it comes to WebDAV downloads. Therefore I immediately continued to test with BitKinex because I had no clue how to fix the size limit by that time. You'll find the solution for this after the BitKinex test.
BitKiney worked like charm. The graph shows the download speed.

DavDrive - BitKinex Performance

Speed was quite good (1,48 MB/s) and by far not as bad as many users have reported when using DavDrive on Windows.
So if you fix your Internet Explorer settings and the size limit, DavDrive should run fine and with reasonable speed on Windows.

Windows Size Limit
To fix the size limit you have to use the registry editor and edit the following key:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters\FileSizeLimitInBytes

DavDrive - Tablet Support

2011-05-30T09:53:00.000-07:00

There is a new version of DavDrive (1.39) and the full version got some enhanced tablet support.
The main screen now presents the usual start button on the left and a list that contains the log entries on the right.


DavDrive 1.39

In default mode the list only shows uploads and downloads so not to confuse the normal user too much. You can switch the display by pressing the small arrow in the activities title bar to display all entries.

Log View Selection

When clicking on these entries a dialog box with some more protocol details is displayed. If the file is present it can be opened.


Log Entry Details

The tablet support is not only for Honeycomb but for all others X-large screens. So other tablet users running Android 2.x should also benefit from the changes.

Log Broadcasts
Another new feature is that the log activities are broadcasted, which means that other programs/activities can listen to these broadcasts and react on these events.

For those interested, here are the details.

Intent Action: de.fun2code.android.webdrive.history.intent.add

Extra	Type	Description
Method	String	Mehthod name in uppercase.
Timestamp	Long	Time in millis.
Resource	String	Complete resource (file) name.
Success	Boolean	True on success, otherwise false.
Code	Integer	HTTP result code.
Message	String	Additional message.

Windows 7 WebDAV Performance

2011-05-17T03:05:00.000-07:00

This bugged me for a while...
DavDrive's WebDAV performance seems o.k. on almost all platforms, except for Windows 7 (and especially the 64 bit version).
I have no Windows 7 at home, so I could not really test.

Today I stumbled over a blog entry by Chief Oddball which suggests a fix.
To make it short, here is the possible fix (quoted form the blog entry):

In Internet Explorer, open the Tools menu, then click Internet Options.
Select the Connections tab.
Click the LAN Settings button.
Uncheck the “Automatically detect settings” box.
Click OK until you’re out of dialog hell.

I'm really interested if this is working.
Comments welcome!

PAW Server & PHP

2011-04-21T12:46:00.000-07:00

In this post I would like to write about what is coming up next in PAW development.
PAW supports BeanShell code to create dynamic pages. BeanShell is well suited for Android, because it integrates will into the OS by supporting the Android Java API.

The foundation of PAW is Brazil a web application framework which was developed by SUN (now Oracle). Although not widely used the framework has the advantage of being very small and flexible.
What I was thinking about for a while was to add PHP support. PHP is widely used around the net. PHP's reputation is questionable and that are people who love and others who hate it. But it's undoubtedly one of the most used frameworks when it comes to web development.

PHP basically comes in two flawors, a CLI and a CGI version. To integrate PHP into the context of a web server the CGI version is needed.

Android PHP Project
Knowing that there is a CLI version provided by the Android PHP Project I headed over to their forum asking if they could provide a CGI version in addition to the CLI version.

Unfortunately the guys told me that a CGI version will not be provided by the project because it's not needed and pointed me to a page which describes shortly how to setup the tool-chain to do a cross compile of PHP.

Cross Compiling
So I tried to compile PHP myself. I have a Linux box at home so I'm quite familiar with doing configure/make and all this things but the last time I dug into C sources and header files is approx. 10 years back. So this was quite a challenge. Finally I got it working, but I think I did a lousy job. So if somebody can do it better, please go ahead and send me the php-cgi binary.

The CGI Handler
After I had the binary I extended and changed the CGI handler that is included with Brazil to work with Android. Due to some changes in the Brazil source that I have done concerning upload size limits the original handler could not be used. In the process I also tried to add SL4A support. I haven't tested this until know, but I hope it will be working.

SL4A Support
SL4A support is a little bit tricky, because one has to know the port the SL4A is listening to. So I looked around how to get hold of the port and found out that the port is reported in the logcat.
So on startup of the handler (on start of the PAW service) the handler looks into logcat and tries to find the SL4A host name and port number. These values are associated with the AP_HOST and AP_PORT environment variables. So SL4A the server has to be started shortly before PAW starts up.

The Plugin
PHP will be available as plugin shortly after the next release of PAW (which should be in the next month). PAW will then come with the new handler. Providing PHP as plugin has the advantage that PAW itself does not grow (much) in size. PHP is approx. 3 MB in size and so relatively large.
The plugin can be downloaded from an external website and extracted into the PAW plugin folder.
A new page showing available plugins will be included into the next PAW release.

Plugins in the Add-Ons menu

After extracting the plugin it should be visible under PAW's plugin menu.

Plugin in the Plug-ins menu

Installation of PHP should be a one click action and after a restart of PAW PHP should be available.

PHP Installation

PHP has been tested using a Google Nexus One and a Notion Ink Adam. The result of phpinfo() can be viewed here.

This is work in progress but it looks promising although not all PHP pages will be working but basic stuff should.

So stay tuned, I hope to finish this in a couple of weeks :)

Note:
PAW for Android 0.58 is now available at the Android Market.
The PHP plug-in is also available.

Cache Stumbler Beta

2011-03-23T10:11:00.000-07:00

Cache Stumbler is a widget that is intended to assist people in finding traditional Geocaches.It is not geared at die hard Geocachers but at people that would like to know which traditional Caches are in reach and how to reach them.

Cache Stumbler tries to answer the question: "Where is the next Cache?"

The widgets shows the name, direction, distance etc. of the nearest cache without the need to register to geocaching.com.


Cache Stumbler Widget

Details of the cache are available by tapping on the widget.

The menu offers the possibility to show the cache on the map, share the cache and mark the cache as found or not-found. When a cache is marked as found/not-found it will be ignored in the future.

Cache Stumbler Details

This is a beta version, so things might not work very reliably or might not work at all.
If some people find it useful I might consider publishing it in the Android market.

Find below the download link, if you would like to try it out. It case of errors it would be nice to get a bug report (preferably with a logcat output attached). Logcat output can be sent by using the app aLogcat available from the Android Market.

Bug report mail address: cachestumbler [at] fun2code.de

Comments are of course welcome :)

Have fun...

Edit:
Cache Stumbler is now available at the Android Market!

PAW Server Widget and App2SD

2011-02-27T06:17:00.000-08:00

Unfortunately there is a bug in Android concerning the handling of widgets in combination with App2SD. For more information see the following bug report: Widget from Apps installing in SDCARD in Froyo not show up

Because of PAW’s size it makes sense to move the app to SD Card. To fix the above issue, here is the widget as separate APK (only 17kB in size).

Downloads:
PAW Server Widget

PAW - MP3 Player

2011-01-28T00:10:00.000-08:00

The next version of PAW (0.56) will feature a MP3 player.


PAW - MP3 Player

The information used by the player is extracted from the Android device's media database. The coverart will be presented by using the jCoverflip jQuery plugin.
For playback the very lightweight (9k) Flash MP3 Player is used.

For those of you who want to try a preview of the player or/and want to have a look at the xhtml source you'll find the download at the end of the post.
Just extract the ZIP file to the root of your SDCard (/sdcard). After that you should find a new entry MP3 Player in the Media menu.

Have fun...

Downloads:
PAW - MP3 Player Preview (ZIP file)

APK Upload and Installation

2011-01-13T11:31:00.000-08:00

After reading this post at XDA Developers I would like to show how APK installation can easily be done with PAW Server without the need of an Internet connection.

PAW Content Sharing - Send to Android

With the new Content Sharing functions this is very easy and can be done in four simple steps:

Go to the System > Share Content menu entry.
Select the APK file for upload.
Select the Use Open URI radio button.
Press the Send Data button.

Now the installation process should start automatically on your Android Device :)

Note: The standard file upload size is 2 MB. This can be changed in the server settings to any size.

Sharing .... the Android Way

2010-12-20T08:15:00.000-08:00

In the upcoming PAW Server for Android release there will be the possibility to share content between Android device and browser by using the integrated Android functionality of sharing content (images, contacts etc.).
Some apps provide a share or send to feature which pops up a selection dialog from which the app that should receives the content can be selected.

With the new PAW release it will be possible to receive and send content by using this functionality.

When the share functionality is enabled in PAW (which will be the default), PAW Server will be visible in the selection menu of any app providing the share feature.

Share menu in Gallery

After selecting the PAW Server menu entry an icon will be displayed in the PAW statusbar to signal that shared content is available:

Statusbar

After clicking on the icon (or the System->Share Content menu) the share page will be displayed, which presents the shared data in a table. When the download link is clicked, the shared content will be downloaded by the browser.


Share from web page

It will be also possible to send files to the Android device by uploading a file and calling the Android share or open URI function. With that it is for example possible to upload APK files and install them in one go without the hassle of uploading the file first and then running it in a separate step.

Upload from web page

For programmers there will be the possibility to access the shared content from within a web application. The shared data will be stored in the server scope of the PAW server.

Flash MP3 Player

2010-12-14T09:33:00.000-08:00

This post demonstrates how the Android MediaStore can be used to play MP3 files directly from the device. As player front-end the Flash MP3 Player is used.

For those of you not interested in the code, there is a ready to install ZIP file at the end of the post.

Flash MP3 Player

All the files are mainly taken directly from the flashmp3player.org website.

Three changes were made:

In the index.html the reference to flashmp3player.php has been changed to flashmp3player.xhtml.
The file flashmp3player.xhtml has been implemented.
The file get_file.xhtml has been copied from the PAW app directory and the PAW access control has been removed. This file provides access to files that are not located within the html root directory of the server. This is a potential security risk, so make sure to protect the flashmp3player folder with a password.

The implementation of flashmp3player.xhtml uses the MediaStore to extract the information about artist, title and file and constructs a XML file for the Flash MP3 Player.

An example XML file looks like this:

<?xml version="1.0" encoding="utf-8"?>
<playlist>
<song id="120"  title="Beat The Bastards" artist="Accept" src="get_file.xhtml?file=%2Fmnt%2Fsdcard%2FMusic%2FAccept%20-%20Blood%20Of%20The%20Nations%2F01%20-%20Beat%20The%20Bastards.mp3" />
<song id="121"  title="Teutonic Terror" artist="Accept" src="get_file.xhtml?file=%2Fmnt%2Fsdcard%2FMusic%2FAccept%20-%20Blood%20Of%20The%20Nations%2F02%20-%20Teutonic%20Terror.mp3" />
<song id="122"  title="The Abyss" artist="Accept" src="get_file.xhtml?file=%2Fmnt%2Fsdcard%2FMusic%2FAccept%20-%20Blood%20Of%20The%20Nations%2F03%20-%20The%20Abyss.mp3" />
<song id="123"  title="Blood Of The Nations" artist="Accept" src="get_file.xhtml?file=%2Fmnt%2Fsdcard%2FMusic%2FAccept%20-%20Blood%20Of%20The%20Nations%2F04%20-%20Blood%20Of%20The%20Nations.mp3" />
</playlist>

Below is the code of the flashmp3player.xhtml file:

<bsh>
import android.net.Uri;

uri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;

String[] tags = new String[] {
android.provider.MediaStore.Audio.Media._ID,
android.provider.MediaStore.Audio.Media.TITLE,
android.provider.MediaStore.Audio.Media.ARTIST,
android.provider.MediaStore.Audio.Media.ALBUM,
android.provider.MediaStore.Audio.Media.DATA
};

service = server.props.get("serviceContext");

cursor = service.getContentResolver().query(uri, tags, null, null, android.provider.MediaStore.Audio.Media.ARTIST + "," + android.provider.MediaStore.Audio.Media.ALBUM);

print("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
print("<playlist>");
cursor.moveToFirst();

do{

  id = cursor.getString(cursor.getColumnIndexOrThrow(android.provider.MediaStore.Audio.Media._ID)).replaceAll("\"", "");
  artist = cursor.getString(cursor.getColumnIndexOrThrow(android.provider.MediaStore.Audio.Media.ARTIST)).replaceAll("\"", "");
  title = cursor.getString(cursor.getColumnIndexOrThrow(android.provider.MediaStore.Audio.Media.TITLE)).replaceAll("\"", "");
  file = cursor.getString(cursor.getColumnIndexOrThrow(android.provider.MediaStore.Audio.Media.DATA));
  file = "get_file.xhtml?file=" + Uri.encode(file);

  if(file.endsWith(".mp3")) { 
 print("<song id=\"" + id + "\"  title=\"" + title + "\" artist=\"" + artist + "\" src=\"" + file + "\" />");
  }
}

while(cursor.moveToNext());
cursor.close();
print("</playlist>");
</bsh>

Downloads:
paw_flashmp3player.zip

Installation:
Unzip into the /sdcard folder of your Android device.
Access http:<ip>:8080/ on your device. The MP3 Player entry should be available in the list of applications.

Attention: There are no access restrictions on the installation directory!

So use this only for a short period of time or password protect the directory by defining a password (PAW Menu -> Server -> Directory Protection).

Uninstall:
Delete the folder /sdcard/paw/html/flashmp3player and the file /sdcard/paw/webconf/apps/x02_flashmp3player.conf.

File Upload

2010-12-14T09:00:00.000-08:00

Since PAW 0.51 file upload sizes are no longer restricted. This restriction has been removed by changing the code of the underlying Brazil framework.
This post shows how file upload can be implemented.

A ready to install ZIP file containig all the code is available at the end of the post.

Since PAW 0.51 requests with content-type multipart/form-data are handled differently. The post request parameters are not handled automatically and processing is left to the application. The InputStream of the request can be accessed by using the instance variabel request.in.

The example consists of two files. One is the html file containing the form which allows the upload of two files.
The second file is the xhtml file containing the code to save the uploaded files to the /sdcard directory of the Android device.

To make the handling of the multipart form data easier the class MultipartStream from the Apache Commons Fileupload package has been added to PAW.
Actually this is an old version of the class which has no dependencies at all.

The html which contains the form is quite simple:

<html>
<head>
  <title>File Upload</title>
  <link rel="stylesheet" href="css/default.css">
</head>
<body>
  <h2>File Upload Demo</h2>
  <p>
  Uploads files to /sdcard...
  </p>

  <form action="fup.xhtml" method="post" enctype="multipart/form-data" >

  File to upload: <input name="upfile1" type="file"><br>
  File to upload: <input name="upfile2" type="file"><br>
  <input value="Upload" type="submit">
  </form>
</body>
</html>

The second file performs the following steps to save the files:

Extract the boundary string from the content-type.
Constructs a MultipartStream object.
Skips the preamble. This ignores all data until the boundary is reached.
Reads the parts until it finds a file. If a file is found it extracts the filename and stores the file in the /sdcard directory.
If the part contains no file, the part's body is skipped.

There is a nice article that discribes this in more detail on oreillynet.com: Parsing form-data multiparts

So now here is the code:

<html>
<head>
<title>File Upload</title>
<link rel="stylesheet" href="css/default.css">
</head>
<body>
<bsh>
import org.paw.util.*;
import org.apache.commons.fileupload.*;

outDir = "/sdcard/fup";
files = new ArrayList();
type = (String) request.headers.get("content-type");

if (type != null &&type.startsWith("multipart/form-data")) {
 try {
  // Get the boundary string
  boundaryIndex = type.indexOf("boundary=");
  byte[] boundary = (type.substring(boundaryIndex + 9)).getBytes();

  // Construct a MultiPartStream with request.in as InputStream
  MultipartStream multipartStream =  new MultipartStream(request.in, boundary);
  boolean nextPart = multipartStream.skipPreamble();

  // Loop through all parts
  while(nextPart) {
    headers = multipartStream.readHeaders();

    // If part is a file, save it to disk. Otherwise skip it.
    if(headers.contains("filename=\"")) {
       // Get filename
       filename = headers.substring(headers.indexOf("filename=") + 10);
       filename = filename.substring(0, filename.indexOf("\""));

       // If filename is not empty save content to filesystem
       if(filename.length() > 0) {
   files.add(filename);
   multipartStream.readBodyData(new FileOutputStream(outDir + "/" + filename));
       }
                     else {
   multipartStream.discardBodyData();  
       }
    }
    else {
       multipartStream.discardBodyData();
    }

    nextPart = multipartStream.readBoundary();
  }
 }
 catch(e) {
  print(e);
 }
}
</bsh>
Uploaded files to <bsh>$$.print(outDir);</bsh>:<br>
<hr>
<bsh>
for(file : files) {
 print(file + "<br>");
}
</bsh>
</body>
</html>

Downloads:
paw_fup.zip

Installation:
Unzip into the /sdcard folder of your Android device.
Access http:<ip>:8080/ on your device. The File Upload Demo entry should be available in the list of applications.

Attention: There are no access restrictions on the installation directory!

So use this only for a short period of time or password protect the directory by defining a password (PAW Menu -> Server -> Directory Protection).

Uninstall:
Delete the folder /sdcard/paw/html/fup and the file /sdcard/paw/webconf/apps/x01_fup.conf.

DavDrive and Nautilus

2010-11-25T13:15:00.000-08:00

If you are using DavDrive in combination with Ubuntu you might notice a bug which prevents you from copying directories from your Android device when using Natilus.
This is not a DavDrive bug but a Nautilus/gvfs bug which is present for more than two years.

For more detail see the Ubuntu bug report #267642.

When copying a directory with Natilus only a file containing the directory listing is produced:

Result of Nautilus directory copy

The bug report mentions a workaround:
Copying directories is possible by using a shell and accessing the ~/.gvfs folder directly.

Directory copy from Shell

Hopefully this nasty bug will be fixed soon.

DavDrive & DAVCommander

2010-11-17T07:03:00.000-08:00

DavDrive allows the browsing of the filesystem from a browser, but this is not very comfortable and does not allow for file upload, file deletion or to create and delete directories.

DAVCommander is a Sourceforge project, that provides a nice WebDAV frontend which can also be used as a Java Applet inside a web browser.
This following blog post shows how DAVCommander can be easily integrated into DavDrive (and DavDrive Lite).

The idea is to put the files needed by DAVCommander (HTML and JAR file) into a folder served by DavDrive and call the HTMLfrom a browser. The HTML contains a JavaScript that builds the <applet> tag with the appropriate WebDAV URL, so that the configuration is done automatically. For all this to work Java has to be installed on your PC and Applets have to work.

For those interested, here is the HTML page:

<script type="text/javascript">

davURL = window.location.protocol + "//"  + window.location.host;

document.write('<body style="background: gray;"><div style="border: 1px solid black;">');
document.write('<applet archive="DAVCommander.jar" code="ch.oxinia.webdav.davcommander.AppletMain.class" width="100%" height="98%">');
document.write('<param name="uri" value="' + davURL + '">');
document.write('<param name="staticUri" value="true">');
document.write('<param name="acl" value="false">');
document.write('<param name="versionControl" value="false">');
document.write('<param name="locking" value="false">');
document.write('<param name="davproperties" value="false">');
document.write('<param name="showTrees" value="false">');
document.write('<param name="multipleSelection" value="true">');
document.write('<param name="dragDrop" value="true">');
document.write('<param name="renameWithDoubleclick" value="false">');
document.write('<param name="lockUiWhileBusy" value="false">');
document.write('<param name="keepAlivePeriod" value="0">');
document.write('<param name="keepAliveUri" value="">');
document.write('</applet>');
document.write('</div></body>');
</script>

Don't worry, installation is very simple and all you need is a simple ZIP file which is provided at the end of the post that has to be extracted to a directory served by DavDrive.

In my example, I'll extract the ZIP file to my /sdcard on my Android device which is also the root folder of my DavDrive setup. After this is done direct the browser to the URL displayed by the DavDrive app, enter user/password and browse to the DAVCommander Folder.


Directory Listing

After selecting the file DAVCommander.html the Applet should be started and after providing user/password (could be more than once) DAVCommander should appear.


DAVCommander

That's it, now you can mange files and folders directly from within your browser.

Downloads:
DAVCommander.zip

PAW Performance

2010-09-22T09:36:00.000-07:00

To test the performance of PAW on Android I created a small web app for PAW Runtime which basically takes a small picture (80x120px) and transforms it into a grayscale and sepia image.

Web App

The transformation was done with native code (compiled into the PAW runtime) and also with pure BeanShell code to get a feel how BeanShell performs.
Main reasons for doing the test were the reports about bad BeanShell performance.

The algorithms used for BeanShell and native code were identical.
Here is the BeabShell code:

import android.graphics.*;
import android.graphics.Bitmap.CompressFormat;

file = parameters.get("file");
filter = parameters.get("filter");
sepia = (filter != null && filter.equals("sepia")) ? true : false;

depth = 20;

if(file != null) {
 bitmap = BitmapFactory.decodeFile(file);

 if(bitmap != null) {
  bitmap2 = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
  w = bitmap.getWidth();
  h = bitmap.getHeight();
  for(x=0; x < w; x++) {
   for(y=0; y < h; y++) {
    c = bitmap.getPixel(x, y);

    r = Color.red(c);
    g = Color.green(c);
    b = Color.blue(c);
     
    gry = (r + g + b) / 3;
    r = g = b = gry;
    
    if(sepia) {
     r = r + (depth * 2);
     g = g + depth;
    }

    if(r > 255) {
      r = 255;
    }
    if(g > 255) {
      g = 255;
    }

    bitmap2.setPixel(x, y, Color.rgb(r, g, b));
   }
  }

  bos = new ByteArrayOutputStream();
  bitmap2.compress(CompressFormat.PNG, 0 /*ignored for PNG*/, bos);
  byte[] bitmapdata = bos.toByteArray();

  request.sendResponse(bitmapdata, "image/png");
  request.out.flush();
  request.out.close();
 }
}

Here is the result after running the test:

Result

Actually BeanShell is much slower than I expected. But if you take into consideration what is happening behind the scenes it's not as surprising as it seems. There is a log of Java reflection, parsing, instantiations etc. going on.
Another result was, that the PAW server itself is performing nicely, which is a good sign.
So from a developer's point of view BeanShell code should be reduced to a minimum and native Android API should be used as much as possible.

What it also means is that, because the PAW Web App uses much BeanShell code, there is room for improvement...

To test it for yourself, download the latest PAW Runtime version and unpack the Image Manipulation ZIP file to your /sdcard/paw-runtime directory.

After that the following menu entry should be available in your PAW Runtime menu:

Menu Entry

PAW Runtime

2010-09-16T07:55:00.000-07:00

PAW Runtime is basically a stripped down PAW Server that only listens to the loopback interface on a random port and with a WebView serving as browser frontend.
With this set-up it is possible to run PAW applications directly on the device.

Everything that's possible with PAW Server is also possible with the runtime version.

Overview

It enables users and programmers to directly develop applications on the device without the need to install a SDK on the PC.
Because the GUI is defined via HTML development of the interface is easy for people that know HTML/CSS and JavaScript.

There are of course limitations to this approach concerning speed and using all features of the platform, but for developing small applications or prototypes this should be sufficient.
What is not possible is to develop individual apps, all PAW Runtime apps reside in the /sdcard/paw-runtime directory and are accessible (when defined in the webconf/apps directory) from the main menu screen.

The runtime itself comes with no applications, but demo applications are available for download.
Below is the main menu with installed demo applications.

Let's have a look at the compass app shown in the first image.

All applications are stored in the /sdcard/paw-runtime/html folder. The application consists of a XHTML file and the corresponding jQuery scripts and images. Together with the demos comes a html/common folder that contains components (like JavaScript files) that can be reused.

Let's have a look at the XHTML file:

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>Compass</title>
<link rel="stylesheet" href="../common/css/default.css">
<script type="text/javascript" src="../common/js/jquery.js"></script>
<script type="text/javascript" src="../common/js/executeScript.js"></script>
<script type="text/javascript" src="js/jquery.rotate.js"></script>
<script type="text/javascript">
$(document).ready(function() {
updateCompass();
});

function updateCompass() {
executeScript('compassScript', null, 'compassRes');
$("#compassImg").rotate($("#compassRes").val() * -1, 'abs');
}
</script>
</head>
<body>
<center>
<h1>Compass</h1>
<img src="images/compass_rose.png" id="compassImg">
<p>
<div style="font-size: 30px; font-style: bold;" id="compass"></div>
</p>
</center>

<input type="hidden" id="compassRes" onChange="$('#compass').html($(this).val() + '°'); setTimeout('updateCompass();', 500);">

<!-- Script -->
<textarea id="compassScript" style="visibility:hidden; display: none;">
import de.fun2code.android.pawserver.AndroidInterface;

sensorListener = AndroidInterface.getSensorListener();
bearing = sensorListener.getOrientBearing();
$$.print(bearing);
</textarea>

</body>
</html>

The part that reads the bearing information of the device is surrounded by BeanShell <bsh>...</bsh> tags.
All the rest is standard HTML/JavaScript. A documentation of the functions provided by PAW comes bundled with the demo applications.

One last thing to do is to define the application's .conf file in the webconf/apps directory, so that the application is available from the main menu.

name=Compass
description=Displays Compass and Bearing
icon=compass/images/compass_rose.png
href=compass/compass.xhtml

APK Download: PawRuntime.apk
Demos Download: PawRuntime_Demos.zip
Eclipse Project: AndroidPawRuntime_Eclipse_Project.zip

Note: Files are based on PAW Server for Android 0.60 beta

The demos can be simply unpacked onto the /sdcard of the device.

PAW Runtime is currently in alpha state.
Comments are welcome...

Sending Web Pages, Market Links and Goolge Map Routes directly to the Phone

2010-06-04T11:03:00.000-07:00

With the new version of PAW (0.38.6) it is now possible to send web pages, market links and Google Maps (routes, Street View) directly to the Android phone*.

The setup is easy. After installing Greasemonkey and two additional scripts (one for the Android Market and one for the web an Google Map pages) the only thing that is left is to configure the Greasemonkey scripts. This is not very hard and should only take a view seconds.

The scripts and instructions are found within PAW's web application, in the Add-Ons section.

Below are some screen shots show the new functionality.

* Google Maps might only be working on devices which are running Android 2.1 and up

SSL Again

2010-03-04T12:08:00.000-08:00

I finally got SSL working in PAW.

The code in the previous post is working. The problem was fixed by disabling keep alive in the Brazil framework.
Actually I can't tell if this is a problem with the Brazil framework or Android.

HTTPS can now be enabled in the PAW server settings.

Anyway it's working and performance does not seem to suffer too much.

PAW Server for Android and SSL

2010-03-02T09:07:00.000-08:00

After receiving user feedback from Stephen I decided to have a look how to implement SSL connections for PAW.

As Stephen pointed out, and of course he is correct, security is not very high in PAW as it is possible to modify data on the device.
First thing I did was to check how SSL works on standard Java.
This was fairly easy and worked on first try:

int port = 9999;
System.setProperty("javax.net.ssl.keyStore", "android-keystore"); System.setProperty("javax.net.ssl.keyStorePassword", "android");
ServerSocketFactory ssocketFactory = SSLServerSocketFactory.getDefault();
ServerSocket ssocket = ssocketFactory.createServerSocket(port);
Socket socket = ssocket.accept();

Unfortunately that didn't work at all on Android. I only received an normal ServerSocket without any SSL support.
After some googeling the code looked like this:

import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.KeyManagerFactory;
import java.security.KeyStore;

        try {
            int port = 9999;
            char[] passphrase = "android".toCharArray();

ctx = SSLContext.getInstance("TLS");

kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());

//BKS
ks = KeyStore.getInstance (KeyStore.getDefaultType());

ks.load(new FileInputStream("/sdcard/pawKeystore"),passphrase);
kmf.init(ks, passphrase);
ctx.init(kmf.getKeyManagers(), null, null);

ssf = ctx.getServerSocketFactory();
ssocket = ssf.createServerSocket(port);
ssocket.accept();

        } catch (e) {
                print(e);
        }

This code is in principle working. Actually the code can be executed inside the PAW BeanShell Console (if a keystore exists).

What I didn't know was that the keystore format on Android is not the same as in standard Java. The format uses by Android is BKS which is not supported by the Java keytool out of the box.

To get BKS working the JCE provider from BouncyCastle has to be downloaded and the JAR file has to be extracted to $JAVA_HOME/jre/lib/ext/. After that the following line has to be added to the file $JAVA_HOME/jre/lib/security/java.security:

security.provider.9=org.bouncycastle.jce.provider.BouncyCastleProvider

The number behind security.provider. depends on your Java installation. After that a keystore file can be created with the following command line:

keytool -genkey -keyalg RSA -keysize 1024 -alias alias -keystore pawKeystore -validity 3650 -storetype BKS

On my Galaxy I noticed that when running the code not all connections were accepted, which was strange. In addition there would be minor changes necessary to the underlying Brazil framework, because SSLSockets throw additional Exceptions which do not occur when standard Sockets are used.

But after setting it all up it didn't work because of connection problems and when it worked from time to time it was horribly slow.
The connections problems might be a problem within Android, because for the application this all should be transparent.

I would have really liked to implement SSL within PAW but at the moment I just don't get it working.