Wednesday, December 10, 2014

PAW - Using JavaMail

I got a question (hello Guy) regarding sending mails via PAW Server.
In this use case an Arduio Uno sends HTTP request to PAW which then sends a mail via SMTP to a mail relay.

 ---------                 ---------------
| Arduino | ---- HTTP --> | Android / PAW | ---- SMTP --> 
 ---------                 ---------------
So far for the setup seems quite easy.
Unfortunately (as so often) this is not as easy as it seems. The Android API does not include means to send mails via SMTP. Something like JavaMail is not included.
This post will show how to use JavaMail together with PAW to implement the above use case.
You'll find a Short and a Long Version. The Short Version contains only the necessary downloads and scripts to get things running.
For those interested in technical detail there is the Long Version which will explain things in more detail.
There is a pitfall when using Gmail. So in case you are a Gmail user, please read Using Gmail in addition.

Short Version

Download this paw_javamail.zip ZIP file from Google Drive and extract it to your PAW installation folder (normally /sdcard/paw) inside the webconf/dex folder.
The ZIP file contains the JavaMail libraries from the javamail-android project together with an utility library to make sending of mails via PAW easier.

After a restart of PAW Server everything should be setup to send mails from the BeanShell console.

Here is a test script:

useDexClasses();

import de.fun2code.paw.mail.*;

// Construct a mail class that holds all the server settings
mail = new Mail("smtp.gmail.com", 587, "user@gmail.com", 
      "password", Mail.TransportType.TLS);

// Send an SMTP message including attachments
mail.sendSmtp("sender@gmail.com", "recipient@whatever.com",
              "Test subject", "Test message ...", new File[] { new File("/sdcard/image1.jpg"), new File("/sdcard/image2.jpg") });


First we create a mail object that holds the SMTP server, authentication and connection settings.
The connection are in this example set to TLS, but could also be SSL or PLAIN.
In this case Gmail ist used but could be any other provider.

The sendSmtp method implements the sending of the mail message and takes sender, recipient, subject, body message and an attachment File array as parameter.
If no attachments should be added, just pass null as parameter.

In case of Gmail you'll have to take additional steps to get this working, please read Using Gmail below.

Using Gmail

When using Gmail, the following Exception is likely to occur:

javax.mail.AuthenticationFailedException

The reason for this is that Google does not allow third party apps to access Gmail by default.
In my case I got a mail from Google which included the following link to lower my Gmail security:

https://www.google.com/settings/security/lesssecureapps

After lowering security, everything worked as expected.

Long Version

Let's get a bit into detail ...

Why is it necessary to use the files form the javamail-android project and why is a separate utility class needed for sending mails?

My first take on JavaMail was to download the JavaMail JAR file from the official Oracle web site and use it within PAW. For JAR files to work on Android devices they have to be converted into Dalvic Executable (DEXed) format. For more info about DEXing, you can have a look at the following blog post: PAW - Dynamic DEX Class Loading

Not all classes can bed converted into DEX format, some just don't work. That's the case with the Activation classes needed by JavaMail. That's why the official libraries cannot be used.
Here comes the javamail-android project to the rescue which provides DEXable JavaMail libraries.
These are the library included inside the  paw_javamail.zip ZIP file.

Inside the ZIP file as well comes a  DEXed version of the de.fun2code.paw.mail.Mail class which implements the sending of SMTP messages. Why do we need that class, couldn't we have just put all that code insde a BeanShell script?

In principle yes, but BeanShell on Android does not have the possibility to compile all (inner) classes. That's just not working for the authentication part of JavaMail. So that's why there is this precompiled additional class, which in addition also hat the advantage of being faster than the equivalent BeanShell code.

Below is the complete de.fun2code.paw.mail.Mail class which uses plain JavaMail.


package de.fun2code.paw.mail;

import java.io.File;
import java.util.Properties;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

/**
 * Class that contains methods to send SMTP messages via JavaMail
 */
public class Mail {
 public static enum TransportType  {
  PLAIN, TLS, SSL
 };
 
 private TransportType transport;
 private String smtpServer;
 private int smtpPort;
 private String username;
 private String password;
 
 /**
  * The constructor takes the basic connection parameters
  * 
  * @param smtpServer  SMTP server name
  * @param smtpPort  SMTP server name
  * @param username  authentication user name
  * @param password  authentication password
  * @param transport  transport type: PLAIN, TLS or SSL
  */
 public Mail(String smtpServer, int smtpPort, String username,
   String password, TransportType transport) {
  this.smtpServer = smtpServer;
  this.smtpPort = smtpPort;
  this.username = username;
  this.password = password;
  this.transport = transport;
 }

 /**
  * Sends a SMTP mail message
  * 
  * @param from     sender name
  * @param to     recipient name
  * @param subject    mail subject
  * @param messageText   body text
  * @param attachments   attachments to attach
  * @throws MessagingException
  */
 public void sendSmtp(String from, String to,
   String subject, String messageText, File[] attachments) throws MessagingException {

  String strPort = String.valueOf(smtpPort);
  
  // Fill basic properties
  Properties props = new Properties();
  props.put("mail.smtp.host", smtpServer);
  props.put("mail.smtp.auth", "true");
  props.put("mail.smtp.port", strPort);
  
  // Add connection properties
  switch(transport) {
   case TLS:
    props.put("mail.smtp.starttls.enable", "true");
    break;
   case SSL:
    System.out.println("Using SSL ...");
    props.put("mail.smtp.socketFactory.port", strPort);
    props.put("mail.smtp.socketFactory.class",
      "javax.net.ssl.SSLSocketFactory");
    break;
   case PLAIN:
    break;
  }
  

  // Create the session
  Session session = Session.getInstance(props,
    new javax.mail.Authenticator() {
     protected PasswordAuthentication getPasswordAuthentication() {
      return new PasswordAuthentication(username, password);
     }
    });

  try {
   // Create MimeMessage
   Message message = new MimeMessage(session);

   // Set from header
   message.setFrom(new InternetAddress(from));

   // Set to header
   message.setRecipients(Message.RecipientType.TO,
     InternetAddress.parse(to));

   // Add subject
   message.setSubject(subject);
   
   // Add attachments if available
   if(attachments != null) {
    Multipart multipart = new MimeMultipart();
    
    // The body message
    MimeBodyPart textPart = new MimeBodyPart();
    textPart.setText(messageText, "utf-8");
    multipart.addBodyPart(textPart);
    
    for(File file : attachments) {
     MimeBodyPart messageBodyPart = new MimeBodyPart();
           DataSource source = new FileDataSource(file.getAbsoluteFile());
           messageBodyPart.setDataHandler(new DataHandler(source));
           messageBodyPart.setFileName(file.getName());
           multipart.addBodyPart(messageBodyPart);
    }
    
    message.setContent(multipart);
   }
   else {
    // Add the body message
    message.setText(messageText);
   }

   // Send the message
   Transport.send(message);

  } catch(MessagingException e) {
   throw e;
  }
  
 }

}


Saturday, November 8, 2014

Microbes - Fast Paced Casual Game

This is a guest post by Michaela presenting her first game Microbes available now on Google Play.

The original post in German can be found here ...


Microbes Promo Video



Yeah, it is finished :)

moreGainE1976's first Android Game is released to play!
Now you can visit the small and cute Microbes on their garbage dump!

Link to Google Play Store: http://goo.gl/Hr1PSX

The Main Characters




This small and green scaredy cat is the smallest Microbe, that is allowed to play on the garbage dump. Its only job is to be afraid and to be eaten.



The next bigger one is the yellow Microbe with the funny snouts as ears. It eats smaller green Microbes and prefers many at once. Nevertheless, it must have to worry if the larger Microbe is near:




These lovely purple lady is the third Microbe. As harmless as she may strum with her eyes, so greedy she is! No yellow Microbe is safe from her!

 

The red Microbe is the hungriest of the four. It hits its teeth in the purple ladies, as it was just starving! There is no escape! And when it ate too much, then it bursts!



To clean up the garbage dump, there is from time to time – as a reward – a small poison bottle. Sometimes – but not always! - the shattered poison bottle lets explode some Microbes, too, and so generates extra points.

And yes, the skull is a cross over to the PirateBox :)

Saturday, October 11, 2014

Wear Shell - Exploring Android Wear

Having a LG G Watch for a while I thought that it would be interesting to run code directly on the watch without having to create an APK. Sometimes I just wanted to run some code snippets on the watch and view the result instantly.
Creating a complete project, compiling and deploying the APK on the Wear device is quite time consuming and somewhat annoying.

I tried to write an app to execute BeanShell code directly on the Wear device. This is all experimental and the possibilities are quite limited compared to an regular app, but for an execution of some code snippets that seemed to be a good idea.

The result is Wear Shell, an app that consists of a mobile and a Wear part. The mobile part moves the code for execution to the smart watch, collects the result and passes it to the calling application.

So I hope owners of an Android Wear smart watch have fun with the app and find it as interesting as I did to explore things from the perspective of a watch.

WearShell App


Web Interface

To make tests easier, the app contains a small (PAW based) web server with a web interface. Inside this interface you can type the code inside a text area, press the Execute button and wait for the result to be displayed.

Web Interface with Wear System Information


The web interface also contains a page containing code snippets for you to try out. These snippets include code for database, Bluetooth and system info access and should provide a good starting point for further explorations.

Developers

Developers have the possibility to use the functionality of the app within their own applications by using a Result Intent.

Action: de.fun2code.android.wear.shell.EXEC
Request String Extra: bsh
Response String Extra: result

Just pass the BeanShell code to execute to the bsh parameter and read the result from the resulting Intent.

Links 

Download: WearShell APK
Discussion: XDA Developers

Tuesday, August 26, 2014

PirateBox for Android - Android Wear

Starting with version 0.53 PirateBox for Android supports Android Wear notifications for uploads and shout messages.

Android Wear support is disabled by default but can be enabled inside the PirateBox preferences. There is a new Android Wear section which currently only has one Wear Notification check-box preference.
As soon as this option is ticked upload and shout notifications will be sent to a connect Wear device.

Android Wear Preference

Whenever a new upload or shout has been processed and sent to the Wear device a notification is displayed on the Android device (the phone) to indicate that new notifications have been transferred to the Wear device. If that notification gets dismissed, all notifications on the smart-watch will also be deleted.

Wear Notification on Phone

On the smart-watch notifications are summarized and presented in chronological order (newer first). The following image describes the flow on the Wear device.

Flow on Wear Device

After the messages have been expanded options are available to open the PirateBox app on the phone and in the case of a file upload to open that file on your phone for display.

Thursday, August 7, 2014

PirateBox for Android - I18N

The latest PirateBox for Android version 0.5.2 adds i18n support to the web interface. It is now possible to change the language of the web interface independent of the phone's langue settings.
This post will show how to add your own translations in a few easy steps ...

The language files are stored inside the piratebox/html/i18n* folder. The file names have the following format: i18n_ISO.properties
The ISO part specified the ISO 639-1 code which defines the language. Here is a list of available ISO language codes: Language Codes according to ISO 639-1

To add your own translation copy the English translation i18n_en.properties file and rename it to your desired language. To take French as an example, the file would be named i18n_fr.properties.

It is important to note that the file encoding has to be ISO-8859-1, otherwise you might have issues displaying the characters correctly inside the web interface.

Now you can start editing the file. The file contains key value pairs separated by an equals (=) sign. All you have to do is to translate the right hand side of the euqation.
Here is an example, the original in English on the left and the French translation on the right:
button.thanks=Thanks                                button.thanks=Merci

If all lines have been translated, copy the  new file to the piratebox/html/i18n folder and you are almost done.

To select the new language simply go to the preferences of the PirateBox app and select Web Interface Language. If everything worked well the language should be available for selection.



After a restart of the server the web interface should show the new translation.
Besides English the web interface is already translation into German. If you have made your own translation, you can send it to me** and I'll include it in the next release***.

Have fun and I hope everything is working as it should ...


Base directory: /data/data/de.fun2code.android.piratebox/files/
** Mail: jochen[at]fun2code.de
*** If there are multiple for the same language, I'll pick one...

Saturday, July 19, 2014

PirateBox for Android - Modding

Here are the workshop slides I prepared for the PirateBox Camp #2 in Lille. Because they were not used at the camp I'll post them here, so they are not lost.
The slides show the range of possible modifications to the PirateBox for Android, ranging form simple preference changes to the more advanced use of the Android API.

Here are the slides, more details and download links are available below the presentation.
 
The first slide shows the Basic Settings that can be changed inside the preferences of the PirateBox app.
These basic settings allow to change things like the SSID name, storage directory etc. without deeper knowledge of the PirateBox.

The next slide Content Modifications shows the settings needed to make basic changes to the HTML, CSS and JavaScript files. After ticking the Content to SD option, the app has to be restarted for the change to take effect. After the restart you should find a folder named piratebox on your SD card (or wherever your external storage file system is located).

Inside the piratebox folder you'll find a directory named html which contains all the HTML, CSS and JavaScript files. If you are making changes to files located inside the html directory, make sure that the option Enable Updates is not ticked to prevent the next update of the app to overwrite your changes.
You will also notice that the html directory contains files with the extension xhtml. These files are html files that, in addition to standard HTML, include dynamic content. Dynamic content is covered in the slides that follow.

The next five slide (Dynamic Pages, Using BeanShell, XHTML Example, XHTML Errors and BeanShell DIY) cover the use of dynamic pages by using BeanShell. The slide named BeanShell DIY contains a download link (available below) that offers you the possibility to execute BeanShell code directly on your device.

The last two slides (Using the Android API and Android API DIY) are targeted at developers that already know the Android API. The Adroid API DIY links to a ZIP file (download below) that contains an example that shows the use of the Android API to access the music stored on the Android device. After unzipping the files to the html directory you should have an additional menu entry named Media inside the menu of your PirateBox start page.

If you are interested in how that works you can inspect the xhtml files included inside the ZIP file. But event if you are not into development the sample might be a nice addition to your PirateBox.

Downloads

The files referred to inside the presentation are available on Google Drive:
camp#2/beanshell.zip
camp#2/android_media.zip

Tuesday, July 15, 2014

PirateShare

PirateShare is an app that tries to simplify file upload to a PirateBox by using Android's share functionality.
On the PirateBox Camp #2 we tried the app and it seems to work quite well.
Android Share Dialog (image by #BiblioBox)

PirateShare was inspired by the PirateFox a PirateBox file sharing app for FireFox OS:

http://ruk.ca/content/piratebox-firefox-os-piratefox
https://github.com/reinvented/piratefox

The  PirateShare app is available for download on Google Drive:
http://t.co/j7oiLJdZuT


The app works like this:

  1. Select one or multiple photos from the Gallery or select file(s) inside a file management app
  2. Select PirateShare from share menu
  3. PirateShare checks if connected to a PirateBox by requesting the ncsi.txt file
  4. If connected PirateShare will upload the file(s)
Upload Dialog

Wednesday, May 21, 2014

PirateBox at Google Play

After quite some testing PirateBox for Android is now available at Google Play.
Thanks a lot to all of you for testing. Special thanks goes to Skyworth S8 for testing and sending in lots of screen shots (see gallery below).

The APKs will also be published to Google Drive, so installation will be possible for devices without Goggle Apps.

In case of errors or if you would like to provide feedback, please send a mail to piratebox[at]fun2code.de or leave a comment below.




Links

PirateBox at Google Play
APKs on Google Drive

Saturday, May 17, 2014

PirateBox Reloaded - Episode III

Version 0.4.4 of PirateBox for Android is now available. This post is about the new and noteworthy features of that version.

If tests go well and I have enough feedback I will make PirateBox for Android available at Google Play. So please fill out the questionnaire ... feedback has been very sparse lately.

Droopy Support

The original PirateBox uses Droopy for file upload. PirateBox for Android uses his own mechanism for file uploads. To be compatible Droopy emulation has been introduced. If the Emulate Droopy option is enabled (which it is by default) files can be uploaded by using port 8080.

PirateBox and PirateFox

This makes it possible to use existing file upload tools. For testing the FireFox OS app PirateFox has been used (see image).

In addition to the file upload feature, a number is added to the uploaded file name if the file already exists. In earlier versions files with the same name were silently overwritten.


Info Widget

Info Widget
To make it easier to see if files were uploaded or new messages are available the new version contains a new widget which displays this information.

The counters should update automatically. If that does not work, you can force an update by tapping the widget.

Tasker/Locale Plugin

To make automation easier the latest version contains a Tasker/Locale plugin.
With this plugin it is possible to define tasks to switch the PirateBox on/off automatically.

Tasker
It has to be noted, that there are problems when using WiFi on/off as trigger. This is likely to not work as expected. I hope I'll be able to fix that in upcoming versions.





Status Broadcasts

This might only be interesting for developers but it is now possible to request the status of the PirateBox externally via broadcast. The new Info Widget uses this functionality and might serve as example.

The broadcast action used for the status request is de.fun2code.android.piratebox.broadcast.intent.STATUS_REQUEST and the PirateBox app will respond with a de.fun2code.android.piratebox.broadcast.intent.STATUS_RESULT broadcast which contains the following extras:

SERVER_STATE
  boolean value: true if the server is running, otherwise false

UPLOAD_NUMBER
  int value: number of uploaded files

SHOUT_NUMBER
  int value: number of shout/chat messages

UPLOAD_DIR
  String value: upload directory location

SHOUT_DIR
  String value: shout/chat directory location


That's it for the new version ... looking forward to receiving more feedback :)

Friday, May 9, 2014

PirateBox Reloaded - Episode II

First of all thanks to all of you who gave feedback regarding the PirateBox for Android. The feedback was very useful and showed that there are problems when running the app on Android 4.x.
Meanwhile I've rooted my Galaxy Nexus (still on stock ROM) running 4.3, so I had the change for in depth testing. The result is version 0.4.0 of the app which includes a different handling of the dnsmasq process. I'll go a little into detail to describe the changes that have been made.

Those of  you not interested can jump directly to the end of this post where the download link is located. I've also added the questionnaire again. It would be really nice if you could provide feedback, it's  really useful.

Wrapping Dnsmasq

In previous version of the app the dnsmasq process was killed and restarted with the --address=/#/. This worked fine on Android 2.x devices but lead to a continuous restart of the AP (Access Point) on Android 4.x devices.
The new approach is different in the way that it does not kill the dnsmasq process but installs a wrapper script that is created before the AP stars and removed afterwards.
For this to work the app saves a copy of the file /system/bin/dnsmasq to /system/bin/dansmasq.pb.real. On start of the PirateBox service the wrapper script is created which overwrites the /system/bin/dnsmasq command. After the AP is started the original dnsmasq binary is restored.
The wrapper script looks like this:

#!/system/bin/sh
exec /system/bin/dnsmasq.pb.real --address=/#/192.168.43.1 $*

The wrapper calls the original dnsmasq binary which is now located at /system/bin/dnsmasq.pb.real with the --address and all other other parameters ($*) the system used to start dnsmasq.

If you look at the process list after starting the AP you should see that the backed up dnsmasq.pb.real is running instead of the real one (dnsmasq).
Here is the result of the ps | grep dnsmasq command:

shell@maguro:/ $ ps | grep dnsmasq
nobody    5088  121   928    496   ffffffff 00000000 S /system/bin/dnsmasq.pb.backup

New Preferences

The preference screen has two new additions. One is the IP address of the AP and the other is the option to restore the original dnsmasq binary.

New Preference Options
In previous versions the IP of the AP could determined after the AP was started and used to restart dnsmasq. This is no longer possible, because the wrapper script has to be created before the AP starts.

On Android most of the devices have the IP address 192.168.43.1 hard coded and I don't believe that there are a lot ROMs with different addresses. Should your AP start with a different IP address, you can still change this by using the new preference setting AP IP Number.

The second new preferences option is called Restore "dnsmasq" Binary. This will, as the name implies, try to restore the original dnsmasq binary. This should not be necessary to used, because the wrapper is removed and replaced by the original binary after the AP has been started. But in case thing do not work as desired when the device is used for standard tethering, this is the option to restore the binary.

Simple Widget

The new version also comes with a simple widget. It is not pretty ... but hey, I'm a developer not an artist ;)
Meanwhile I've updated the widget images in version 0.4.1, hope the widget is looking a bit better.

Below are the links to the app, the questionnaire and to the source code located at GitHub.
So I hope the new version is working better as the previous version and I'm looking forward for your feedback.



Source Code

The source code is now available on GitHub.

Download Links

Google Drive: PirateBox APKs

Questionnaire

The results can be viewed here, so you know on which configurations PirateBox is running.

Thursday, March 27, 2014

A Look at Android Wear

Google released Android Wear a version of the Android OS specifically designed for wearable device like smart watches and the like.
Actual devices should follow shortly by the middle of this year starting with smart watches from Motorola and LG.

Along with the announcement of Android Wear Google released a preview version of the Android Wear SDK for developers to test and try the new OS.
Looking at the SDKs emulator and docs thing might look a little bit disappointing at first glance, if the expectation is that reals apps can be installed on an Android Wear device.
The Wear API is designed that the wearable device is showing notifications from an Android phone by using the since Android 4.3 Jelly Bean available Notification Access service. This service allows apps to receive information about notifications displayed on device notification bar. In earlier versions of Android this was only available by using the Accessibility feature of Android.

To connect a device to an Android Wear emulator, Google has provided an Android Wear Preview app for registered developers. Because using the above mentioned “Notification Access” service, this app only runs on devices with Android 4.3 or higher.
When the app is enabled all (non ongoing) notifications will be displayed on the Android Wear device with the ability to use rich notifications which allow to use action buttons for sending Intents back to the smart phone.
This design has the advantage that without any change current apps will work with Android Wear out of box.

The possibilities currently available with that notification approach are quite limited and can be viewed on the Android Wear developer page.

In summary developers can use the following notification types:

  • Rich notifications including images and action buttons
  • Grouped notifications
  • Notifications with multiple pages
  • Receive voice input from a notification


That seems to be it as far as the official API concerned. But the question arises (at least from a hacker’s perspective) … Can the Android Wear OS run regular apps?

If we have a look at the above linked developer page, it states:

“Caution: Do not install apps on the Android Wear emulator. The system does not support traditional Android apps and the result of running such apps is unpredictable.”

It is indeed possible to run apps with some exceptions. Network access is not possible and in the case of most apps will lead to a crash of the app. Web Views are also not supported. Apart from that, apps seem to work fine, but the small display size might be a problem.
Because this is a block for developers and hackers, let’s have a look how to run apps on the Android Device emulator.

First of all an APK of an app is needed that does not require network access. An example of such an app is the StopWatch & Timer app from Google Play.
The APK can be extracted from another Android device with a backup app. Using APK Backup of the PAW web interface is also an option.
The APK can be simply installed onto an emulator running Android Wear with the following command:

adb install

When the APK has been installed, the app StopWatch & Timer app can be started like this:

adb shell am start -n com.sportstracklive.stopwatch/com.sportstracklive.stopwatch.BigStopWatchActivity

After startup the app will show up on the emulator’s screen. Apart from the  small screen estate, the app seems to be working fine. Event the preference screen is working.

All in all Android Wear seems to be a nice addition to the Android family and summer seems to be getting interesting with new devices popping up.

Sunday, March 16, 2014

Writing/Deleting Data with KitKat

Unfortunately Android 4.4 KitKat does restrict file access to the secondary SD card when it comes to writing and deleting files.

This restriction was actually introduced in Android 3.2 HoneyComb but was not enforced by device manufacturers.

With KitKat this seems to have changed (e.g. for Samsung devices) and so File-Managers including DavDrive can not write or delete files on the secondary SD card on some devices.
There is nothing that can be done from a software perspective, the only chance to change this is to root the device.

A detailed description can be found here:

External Blues: Google Has Brought Big Changes To SD Cards In KitKat, And Even Samsung Is Implementing Them


Thanks to Stefan for letting me know about this issue!