If you like the result, the stylist’s name is Dustin. Tell him that Anton and Mike referred him (the guys who got crazy Burning Man lines).

The scariest thought right now is how I’m gonna go to work after Burning Man…

So, I moved to San Francisco 4 days ago to start my new job. When I was packing up my things, I just had too much stuff. As a result, I decided to sell a whole bunch of my things to reduce the cost of moving. Obviously, among the first victims was my longboard. My baby served me well for the past year and a half, and I really didn’t want to give it up. However, it was just not meant to be. There was no chance I would fit it in one of my suitcases and shipping it would be just too expensive. So I sold it to a nice kid in Toronto with a thought that I would buy an even better board, when I get to SF.

Once I sold the board, I started looking around for the hip things on the market. At first, I settled on getting the Apex 37 from the Original Skateboards. Originals have become quite popular in the past couple of years, and it seemed like a great choice. The Original boards are famous for the their spring-based trucks that are amazing carving machines. As a result, they are not really made for bombing hills, which is kinda what I was looking for. Apex 37 is a great all-around board, but it can get quite wobbly at  higher speeds.

Moreover, for the past couple of months the Apex 37 and Apex 34 have been out of stock. People at Original’s Facebook page claimed that it might take a few months until the boards come back in stock. This was no option for me, as I really didn’t want to spend a couple of months without a board.

I decided to take a walk to one of the best skate shops in San Francisco - Skates on Haight and see what they have to offer. There I talked to Carol Sloan, the owner, who is probably one of the most knowledgeable people in the skating business that I have ever talked to. She told me that the delays with shipment of Original’s is probably due to a recent strike of the Chinese manufactures. Moreover, I talked to her about another board that I was considering - the Loaded Dervish. She said that it was a great choice for my needs and helped pick out a great setup, which cost me around 321$ with all taxes included:

• Loaded Dervish Flex 1
• Abec 11 BigZigs Lemon 75mm/83a
• Paris 180mm Crimson Slide

I definitely recommend anyone, who is looking into buy a board in San Francisco, to check out Skates on Haight. People there are great.

Anyways, enough of my rant. Let’s check out the pictures of my new baby (click for large images):

However, there is a limitation here. CheckedTextView has to be the root element of the layout that you use for your items. So if you wish to display multiple things (user name and email) for each item  by using a LinearLayout, you are out of luck. The reason for this limitation is that he root item must implement the Checkable interface and the LinearLayout doesn’t implement it.

The solution here is to…

…override  LinearLayout to implement the required interface. I present to you CheckableLinearLayout. Upon inflation it searches through its children for the CheckedTextView, and then forwards any calls required by the Checkable interfaces to that component:
Now, we can use that component in the layout file for our list items:
Make sure you set in your ListView’s XML: android:choiceMode=”multipleChoice”.

This class is now a part of my Android library Begemot.

Follow me @tokudu

Hello everyone. In this post I will try to provide you with a quick example on how to implement push notifications for your Android app using MQTT protocol. I will NOT discuss here why an application might need push notifications or the advantages of Push over Pull. I assume that you know exactly what I mean by push notifications are and why you might need them. However, before jumping in straight to the good stuff, let’s go over how it all started.

Introduction

It’s been around 4 months now since I’ve started developing apps on the Android platform. It began with me scoring a free Nexus One phone at one of the Android Developer Labs.  Obviously, I couldn’t resist trying to hack around with some code, so I downloaded the SDK and dove in. I guess in some sense, that’s exactly what Google was hoping for when they starting giving out free phones. While it might sound like I got lucky, in the end Google is the one who won.

Anyway, developing for the Android platform turned out to the a pleasure. The SDK was easy to setup, easy to use and and easy to understand. Putting together your first app was a breeze. I was very impressed.

Unfortunately, I soon realized that Android is not perfect. One of the things that really disappointed me was the lack of a native method for performing push notifications. Over the past year push notifications became almost a standard in the mobile space thanks to Apple. Even though BlackBerry utlilized Push since god knows when, it was Apple that really brought Push mainstream. Obviously, lack of native Push on Android seems like a huge drawback. Naturally, I started looking around for a solution. After Googling through dozens and dozens of blogs and message boards, I’ve realized that there are 3 generally accepted ways to implement push notifications for your Android app. All of which are non-trivial, hacky and have their own disadvantages. Let’s go over the list:

• Poll? The name obviously tells you that it’s really not even push. The idea here is to periodically poll the server for new messages from a background local or remote service. The more often you poll the closer you get to the real-time push.

• SMS Android allows you to intercept SMS messages. Your server sends a specially encoded SMS to your phone, whenever there is something new. Your app intercepts all messages, looks for the ones from the server, then pops up a notification.

• Persistent TCP/IP The phone initiates a long-lived mostly idle TCP/IP connection with the server and maintains it by occasionally sending keepalive messages. Whenever there is something new on the server, it sends a messages to the phone over the TCP connection.

The first two methods have significant disadvantages that we cannot do anything about. However, the third method’s drawbacks are not as severe. It seems like with enough work and a good design, the persistent TCP/IP method can work. After all, that’s how GMail, GTalk and Google Voice implement their real-time updates. In fact, many developers out there agree that it is probably the best way to go until Google actually takes the matter in their own hands.

Persistent TCP/IP

After more Googling around I was able to come across three reasonable efforts to implement push notifications using a persistent TCP/IP connection:

• Josh Guilfoyle talks about how to create a most-idle TCP/IP connection with a long keep-alive timer based on the AlarmManager. He provides some really cool sample code with a service that runs in the background and makes connections. http://devtcg.blogspot.com/2009/01/push-services-implementing-persistent.html
• Dave Rea recently started the Deacon project, which is aimed at developing a 3rd party library for Android push notifications using comet technology based on the Meteor server. The project is still in a very early stage (at the time of this post), but looks quite promising. http://deacon.daverea.com/
• Dale Lane had done a number of presentations, where he talked about using the IBM developed MQTT protocol for implementing Android push notifications. He also provides some really useful sample Android code. http://dalelane.co.uk/blog/?p=938

While all of the work done by these guys is incredible, none of their results are quite ready for drop-in use by other developers. In my effort to implement push notifications, I decided to put the pieces of the puzzle together and combine their results to produce a relatively stable way of implementing push. The example that I provide you with further, is a combination of Josh Guilfoyle’s TestKeepAlive project and Dale Lane’s MQTT work. I borrow quite a bit of code from those guys, so they should get most of the credit.  Anyways, enough for the introduction, let’s get to the good stuff.

My Idea

The problem with the TestKeepAlive project is that it creates a raw TCP connection, which means that you need write your own server to take care of push on the other side. While it’s, without a question, doable, it is exactly why TestKeepAlive is far from a working solution. On the other hand, the MQTT example shown by Dale Lane uses the IBM’s MQTT broker to handle the server work. To backup a little, MQTT stands for MQ Telemetry Transport, which is a protocol developed by IBM. Let’s take a quick look at the man page:

mqtt is a publish/subscribe messaging protocol intended that is designed to be lightweight. It is useful for use with low power sensors, but is applicable to many scenarios.

Did you see the part about ‘low power’? So did I. Basically, the reason why one might consider using MQTT is that it was designed to be very lightweight, so that it doesn’t consume much power. This is ideal for a mobile push solution as it addresses many battery life related concerns about persistent TCP/IP connections. Obviously, MQTT also has some disadvantages such as privacy, but we can talk about that later.

So, my idea consists of taking a KeepAliveService and replacing the raw TCP/IP connection with an MQTT connection. In this case, each device can simply subscribe to a unique topic which is based on its device ID. Now, assuming that your server knows the device ID, it can push data to the device over MQTT by publishing to that unique topic.

Architecture

In my example, I utilize a PHP script as a server. This uses the Simple Asynchronous Messaging  library (see project SAM http://project-sam.awardspace.com/) to publish MQTT messages to the broker on which I host on my server. Let’s have a look at the overall system diagram:

wmqtt.jar is a simple drop-in implementation of MQTT protocol provided by IBM. It can be downloaded from http://www-01.ibm.com/support/docview.wss?rs=171&uid=swg24006006. The file that you download has a bunch of different stuff. Just look for the right jar file. You can include this jar as a part of your Android app.

Really Small Message Broker (RSMB) is a simple MQTT broker also provided by IBM http://www.alphaworks.ibm.com/tech/rsmb. It runs on port 1883 by default. In our architecture it accepts messages from the server and passes them on to the right devices. RSMB can also be replaced by the Mosquitto server http://mosquitto.atchoo.org/.

SAM is a drop-in PHP library for MQTT and other stuff. You can either get it as PECL extension or download the source online http://pecl.php.net/package/sam/download/0.2.0.

send_mqtt.php is a simple PHP script that accepts messages over POST and uses SAM to pass-on messages to the broker.

Sample Code and Demo

The goal of my work on push notifications was to develop a working demo, which is what all other examples out there lack. I’m happy to say that I accomplished my objective. You can download the sample android app on GitHub.

This app (shown on the left) has a TextView and two buttons. The TextView contains your device ID and the buttons are used to start and stop the push notifications service. Once you have the app on your phone, start the service. Then go to http://tokudu.com/demo/android-push/ and enter the device ID in the first text box and enter the message text in the textarea below. Press “Send Push Message” and you should get a notification on your phone. It’s as easy as that.

You can see the source code for andoid-push in this GitHub project. It contains the aforementioned send_mqtt.php script.

If you didn’t get a notification, make sure you have network connectivity. It can also be that the broker is down on my server (see server status on the page). If that’s the case, please post a comment and I will look into it bringing the broker back up.

Final Thoughts and Comments

MQTT is definitely not the best way to implement push for Android, but it does work. One of the main drawbacks of MQTT is that anyone who knows the IP and the PORT at which the broker is running can connect and intercept your Push messages. So it’s probably a good idea to encrypt them. Alternatively, you could write your own broker and introduce some sort of authentication to MQTT.

The code I provide here for the push service still needs more testing. Reliability is definitely the main question. I think the code can definitely be improved to better handle connectivity loss and other erroneous situations. You are welcome to post your comments here regarding how it can be improved.

Also let me know if you find any bad bugs. Good luck testing!

Anton Lopyrev

Follow me on twitter @tokudu