Direct Link To HoneyGram In The Android Market

I have been doing incremental updates to HoneyGram the last couple of months and just recently got my hands on a Galaxy Nexus as well as GoogleTV 3.1 update, so I spent a few hours tweaking the app to support those platforms.  Upgrading was fairly painless with most tweaks going to layout and resource xml files and simply needing to include a layout-xlarge/ resources-xlarge with tablet specific resources and then tweaking the standard layout/ and resource/ directories to support both phone and television devices.  HoneyComb apps show up automatically for ICS in the Android Market and GoogleTV apps only need a few tweaks to be visible by those devices.

A few issues I ran in to:

1. A webview inside of a DialogFragment gets full screened in ICS so when redirecting back to the app it launches a new Main Activity even though I had launchMode=”singleTop” I fixed this by switching it to launchMode=”singleTask”
2. The text color for tab navigation labels are a little tricky to change.  I needed two sets of values/styles.xml  since ICS displays tabs on the line under the ActionBar the color used is the background of the main activity instead of the action bar.  I ended up having white on white text to background on phones and white on brown on tablets, but this was easy to fix by specifying a special values-xlarge/ resource directory with tweaked colors and text sizes.
3. Still having trouble getting the StackView widget to display and scroll properly on GoogleTV. StackViews inside of normal Activities don’t seem to work with the GoogleTV keyboard.
4. In order to have your app show up on the GoogleTV market you need to set the following in your manifest:<uses-feature android:name=”android.hardware.touchscreen” android:required=”false”/>

   You also can’t use GPS permissions since GTV’s do not have GPS chips (that I know of) so remove Permissions.ACCESS_FINE_LOCATION  and any GPS_PROVIDER code you have.

5. Make sure you use the OnSelectedItemClicked listeners for ListView/GridViews or arrow and enter buttons on GoogleTV will not work properly.
6. GridViews with ImageViews in them are difficult to size and layout properly, I am ending up with whitespace inbetween my columns that make the interface look funny, still working on fixing this.
7. Enable system level cache for Http Requests using the information on this page.  Seems to slow down things a little on ICS but it may just be my connection conditions.

I have released a simple casual game on the Android Market. I decided to make a quick game while between jobs to see how the market has changed since I released my last game about a year ago. I decided to dust off a 2D OpenGL ES engine I wrote about a year and a half ago. It also uses custom Box2d JNI bindings and the Android NDK for physics. I have also integrated the new Android LVL licensing system, OpenFeint leader boards and achievements, and obfuscation using Proguard. It is designed specifically for hdpi devices and I am excited to see how it works on some of the upcoming Android tablets.

One snag I hit was when obfuscating with Proguard and having classes with JNI methods, these classes need to be “kept” by the proguard config file so that the method names and package still match the JNI headers and native source compiled by the NDK:

-keep class com.awalkingcity.casual2d.box2d.Box2DContext {;}

Another thing I am attempting to do is limit which devices can see the app in the market. The app was designed for HDPI screens as well as devices with faster processors than some of the first generation Android devices. Limiting by screen size does not work because the phones I am trying to target report both Medium and Large. So what I tried doing was adding “uses-feature” android:glEsVersion=”0×00020000″. My reasoning is that faster hdpi devices support OpenGL ES 2.0 while slower devices do not. I am not sure whether some of the custom ROMs out there hack OpenGL ES 2.0 support into the older devices or at least spoof support for it.

I am going to update this post with a couple of more tips and tricks I encountered while developing this game.

Here is the market description and some screen shots:

Monkey Fill is a simple and addicting physics game!

The goal is to fill the screen with monkeys while avoiding the bouncing green balls.

Hold down and drag your finger to grow monkeys.They will stop growing if they touch another monkey or pop if they hit a ball.

After one day of being on sale it became very obvious a free version is needed to drive sales of the full version, so I created a limited free version, we will see how well it does in the sea of free apps in the market.

Here is the OpenFeint listing: Monkey Fill

Twitter recently made a streaming API available that allows developers to get real-time status updates using HTTP streaming. You can read about the specifics of the API here. There are a few different levels of streaming that developers can use, most of the more heavyweight streams require explicit permission and some kind of agreement with Twitter. Streams are available in JSON and XML, you can also get a delimited stream which tells you how many bytes each status uses to make I/O a little easier. I am going to show you how to use Apache HttpClient 4.0 and the XPP XML Pull Parser library to write a simple client to consume the publicly available “spritzer” stream.

Setting Up The Client
The first step is to set up the HTTP client. The API uses your twitter username and password with basic authentication to authenticate. We will configure our HttpClient with our twitter user name and password as the credentials for the “stream.twitter.com” scope.

        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, "utf-8");

         SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

         ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(params,
                registry);
        DefaultHttpClient client = new DefaultHttpClient(manager, params);

        client.getCredentialsProvider().setCredentials(new AuthScope("stream.twitter.com", 80),
                new UsernamePasswordCredentials("username", "password"));

Requesting And Parsing
Next we will create the Get request for the “spritzer” stream and perform the request. After that we will open a pull parser on the network stream and “pull” the xml from the stream as it comes in.

Each status update comes in the format:

<?xml version="1.0" encoding="UTF-8"?>
<status>
....
</status>

It is important to note that each status has the xml document tag at the beginning.

Most of the parsing code is the result of a lot of trial and error so it is not the prettiest. See the comments towards the bottom for some important comments about the implementation.

        HttpGet get = new HttpGet("http://stream.twitter.com/spritzer.xml");
        try {
            HttpResponse resp = client.execute(get);
            int statusCode = resp.getStatusLine().getStatusCode();

        if (statusCode == 200) {
                InputStream stream = resp.getEntity().getContent();
                XmlPullParserFactory factory;
                factory = XmlPullParserFactory.newInstance();
                XmlPullParser parser = factory.newPullParser();

                parser.setInput(stream, "utf-8");
                while (true) {
                    int event = parser.next();
                    if (event == XmlPullParser.START_TAG) {
                        String name = parser.getName();
                        if (name.equals("status")) {
                            String text = null;
                            String screenName = null;
                            while (true) {
                                event = parser.next();
                                if (event == XmlPullParser.START_TAG) {
                                    name = parser.getName();
                                    if (name.equals("text")) {
                                        text = parser.nextText();
                                    } else if (name.equals("user")) {
                                        String userName;
                                        while (true) {
                                            int eventUser;
                                            eventUser = parser.next();
                                            userName = parser.getName();
                                            if (eventUser == XmlPullParser.START_TAG) {
                                                if (userName.equals("screen_name")) {
                                                    screenName = parser.nextText();
                                                }
                                            } else if (eventUser == XmlPullParser.END_TAG
                                                    && userName.equals(("user"))) {
                                                break;
                                            }
                                        }
                                    }
                                } else if (event == XmlPullParser.END_TAG
                                        && parser.getName().equals("status")){
                                    break;
                                }

                            }
                            //output username and status to console, you will want to parse and dispatch whatever
                            //information you need to something that does something a bit more substantial

                            System.out.println(screenName + ": " + text); //insert money making method here

                            //IMPORTANT HACK
                            //because each stream starts with an <xml/> document tag
                            //we have to reset the input of the parser to the stream
                            parser.setInput(stream, "utf-8");
                        }
                    } else if (event == XmlPullParser.END_TAG
                            && parser.getName().equals("statuses"))
                        break;

                }

            }

        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        }

Here is the entire source you should be able to build it and run it in the console without many problems, but remember never try to actually read the stream.

The G1 came out this week and I have been putting it through the paces. I really like the seamless transition between developing with the emulator and developing on the device. I think overall it is a very strong first device for Android, but I think that normal users may not recognize some of the more powerful features of the platform.

The Intent system allows for applications and activities to interact with each other, so that you can have applications using the features of other applications. I think this is a really interesting concept and think it could lead to a less application-centric view of phone operation towards a more feature-centric view. Instead of developing an entire application, developers can develop specific features that perform a very specific task. These features can be used by other applications to create new and interesting functionality.

I think the best example of this concept is Barcode Scanner. Barcode Scanner is the application specific manifestation of ZXing which I blogged about previously. Installing it lets you scan bar and QR Codes and lets you perform search actions or interact with the results(like an e-mail address or phone number). The two shopping applications CompareAnywhere and ShopSavvy use the ZXing library themselves for doing barcode scanning, but they include the ZXing library as part of their application bundle.

In my previous entry I mentioned that I would like to see specific Intents that let you use the encoding and decoding ability of ZXing from other applications and the ZXing team responded that the latest build had this exact functionality! Now all you have to do is install Barcode Scanner on your phone and your applications can take advantage of its features. Specifically, it provides Intents that allow your application to use the encoding and decoding functionality. The Intent mechanism makes it almost too simple to integrate this functionality into your application.

Encoding – “com.google.zxing.client.android.ENCODE”

To encode a string into a QR Code Simply create an Intent with the Decode action specified, two string extras specifying the Type and Data and call startActivity():

Intent intent = new Intent("com.google.zxing.client.android.ENCODE");
				intent.addCategory(Intent.CATEGORY_DEFAULT);
				intent.putExtra("ENCODE_TYPE", "TEXT_TYPE");
				intent.putExtra("ENCODE_DATA","HELLO WORLD");
startActivity(intent);

The string values for the Intents and the extras values can be found in the Intents and Content classes in the ZXing source code.

Decoding – “com.google.zxing.client.android.SCAN”

Bringing up the decoding camera interface is just as easy as encoding with the added step of having it return the decoded value of the barcode to our main application.

Intent intent = new Intent("com.google.zxing.client.android.SCAN");
				intent.addCategory(Intent.CATEGORY_DEFAULT);
				startActivityForResult(tent,0);

The big difference here is that we are using startActivityForResult which will allow the scanning activity to return the results of the scan back to our app. In the Activity that launched the decode intent we can extract the results of the scan in the onActivityResult method by simply accessing the string extra “SCAN_RESULT”.

data.getStringExtra("SCAN_RESULT");

You can now use these features to do all kinds of interesting things. I am currently interested in transferring data between phones by encoding the data in a QR code and having the other phone retrieve it by simply pointing it at the other camera’s screen. You could also encode movie ticket information into a QR code and have it displayed on the phone so it can be scanned at the theater.

I hope this post showed you how useful Barcode Scanner can be for your application and it’s users. Now if someone could do something about the reviewers in the android app store…..