Honeycomb – Wiebe Elsinga

Handlers and AsyncTasks, Android doing multithreading

W.Elsinga — Sun, 17 Jul 2011 22:50:35 +0000

Multithreading is always tricky. On any platform and in any language, when not implemented properly you will get unexpected behavior sooner or later.

In the process of making an Android application suitable for Honeycomb, a colleague of mine ran into the NetworkOnMainThreadException, which is new in Honeycomb. On earlier Android versions, doing heavy operations on the main thread was strongly discouraged, but still possible. Now, the OS is forcing the developer to implement a proper application structure. Which isn’t a bad thing at all.

So, to solve the NetworkOnMainThreadException, network and other heavy operations needed to move to a background thread. Considering the structure of the application, the most logical choice was to use the Handler in combination with a Thread.

Basic setup HandlerThread

Here is an example:

public class MBOutcomeHandlerThread extends Thread
{
public MBOutcomeHandlerThread(String name)
{
super(name);
}

private MBOutcomeHandler _outcomeHandler;

@Override
public void run()
{
try
{
Looper.prepare();

_outcomeHandler = new MBOutcomeHandler();

Looper.loop();
}
catch (Throwable e)
{
Log.e("Log", "Thread stopped due to error", e);
}
}

public MBOutcomeHandler getOutcomeHandler()
{
return _outcomeHandler;
}
}

Looper.prepare creates a new Looper instance for this thread, which then creates a new MessageQueue that Handlers can use to post messages on.

MBOutcomeHandler is a subclass of Handler, which implements the handleMessage method. The constructor of the Handler class associates with the Looper.

Looper.loop starts the Looper and keeps the thread alive. The Looper can be stopped by invoking Looper.quit. This will end run method of the Thread, hence, the Thread is finished.

It is also possible to use the HandlerThread class. This class does the Looper setup for you. It doesn’t really matter which one you choose, as long as you don’t forget to instantiate the Handler inside the run method. When using the HandlerThread you must instantiate the Handler in the onLooperPrepared method.

public class MBOutcomeHandlerThread extends HandlerThread
{
private MBOutcomeHandler _outcomeHandler;

public MBOutcomeHandlerThread(String name)
{
super(name);
}

@Override
public void run()
{
super.run();
_outcomeHandler = null;
}

@Override
protected void onLooperPrepared()
{
_outcomeHandler = new MBOutcomeHandler();
}

public MBOutcomeHandler getOutcomeHandler()
{
return _outcomeHandler;
}
}

Now that we have a HandlerThread running, we can use the Handler to send messages to the Looper.

Please be aware, that the HandlerThread keeps looping until the quit method is invoked. It doesn’t really matter if you use the instance of the HandlerThread, the Handler or the Looper. After the quit method is invoked, the HandlerThread is finished and cannot be started again. For example, if the HandlerThread has been quit because the Activity was pushed to the background, you need to clean up the HandlerThread in an onPause or onStop. When the Activity comes to the foreground again, a new HandlerThread must be created. Of course, the starting and stopping of the HandlerThread depends on what kind of operations are performed in the Handler. Then again, I think it is good practice to do a little clean up, instead of Android doing all the work.

AsyncTasks

After the new Handler was created, the next problem occurred. After pushing the application to the background and let it come to the foreground again, the application crashed because of the following error: Handler{4062bc78} sending message to a Handler on a dead thread. Because I was implementing a Handler, I assumed the exception had something to do with the Handler I created. After a lot of searching and debugging, the cause of the exception were the AsyncTasks that are used inside the Handler. Then, after reading the documentation of AsyncTask, Android is very clear that AsyncTasks must be created and started on the UI thread. But, in the process of moving code to the handler, that was overlooked. After creating and starting the AsyncTasks, everything worked fine!

Recap

HandlerThreads and Handlers are a great way to handle heavy or long during operations on a separate thread. When using AsyncTasks in your Handler, make sure that they’re created on the UI thread.

How-To: Android emulator performance tuning tips

W.Elsinga — Sun, 10 Jul 2011 23:30:10 +0000

As some of you may already noticed, running Android Honeycomb application on the Android emulator, isn’t the most fun thing to do, because it’s painfully slow. Besides the start-up time (can be avoided, which I explain later), just using it is a pain. Google is planning to improve the performance, but if you can’t wait that long I’ve put together a few tips which may help improve your experience.

– Emulated memory size.
By default the Honeycomb AVD is created to emulate 256MB of RAM, my advice is to increase this significant, I’m using 1GB (1024MB).
If you’re creating the AVD for Honeycomb in Eclipse you’ll find the RAM setting in the Hardware section under “Device ram size”. If you already have an AVD you can increase the setting by finding the directory you’re AVD is in (e.g. .android/avd/honeycomb.avd), editing the emulator-user.ini file, and changing hw.ramSize to whatever you want the ram size to be in MB.

– Enable Snapshots.
Enabling snapshots on an AVD allows the emulator to start-up an AVD in the state it was in when you closed it. This means that it doesn’t have to go through the boot-up procedure each time, which will save you a reasonable chunk of time.
First on the initial launch make sure you select “Save to snapshot”. Get the emulator up and running and put it into the state you want. I like to have it start at the desktop (home screen) view. Now close the emulator. I found that it wasn’t very responsive when closing, so wait a bit, watch the mouse icon go to “busy” and let it write everything to disk.
Now, launch the emulator again and this time uncheck “Save to snapshot” but make sure Launch from snapshot is chosen. Voila! The emulator launches quickly. And when you save it it shuts down quickly because it’s not saving anymore.

Android and Google TV

W.Elsinga — Fri, 08 Apr 2011 05:10:37 +0000

Watching what the sessions will be at the Google IO 2011, a couple of things stand out..

First, Android apps can be used by Google TV. Google TV already announced this at last year’s developer’s conference.

Also on the agenda is a “Honeycomb highlights” session. It’s no great surprise that we’ll see more of the Android version that is first coming to tablets, supposedly in the first quarter of the year.

The best Android tablets of 2011 compared with infographic

W.Elsinga — Wed, 06 Apr 2011 22:19:08 +0000

The Android tablet market is being flooded with announcement of new Android 3.0 Honeycomb products for release this year. Up until now no one has taken on task of comparing all of them in one place. Well our friends over at Android Authority have done just that with a very detailed infographic.

The chart pretty much speaks for itself and most all of the useful information is included. The next chart compares to the lower priced options available

There you have a comparison off all the Android tablets that will be on the horizon during 2011. Which tablet are you keeping your eye on?

Source Android Authority

How-To: Android Fragments

W.Elsinga — Tue, 22 Mar 2011 02:12:10 +0000

Typically, an Android user interface is composed of views within layouts, such as a ListView within a LinearLayout. A hierarchy of View objects gets loaded or created when an Activity is started. On small screens, this is fine.
But when you spread a UI out over the surface of a tablet’s screen, it calls for a different style of interaction. Some parts of the screen should remain constant over longer durations than others

While developers can implement interactions where parts of the screen change by showing and hiding views, Android’s developers decided they needed more than just convention to encourage better large screen UIs and consistent implementation of the feel of the UI. Now, in order to facilitate this new kind of interaction, as part of the Android 3.0 SDK, we get a class called Fragment.

A Fragment object is something between a View and and Activity: It can be part of a layout, but it isn’t a subclass of View.
It implements the ComponentCallbacks interface, and it has a lifecycle, but that lifecycle is dependent on the Activity the Fragment object belongs to.
Let’s see what it can do in a tablet-sized user interface.

Here are the contents of the main.xml file that describes a screen layout for our application. In a list on the left of the screen some numbers will appear. Selecting a number from that list will create that many Android icons, displayed in a Fragment instance on the right.

xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/frags">

android:id="@+id/number_list"
android:layout_width="250dip"
android:layout_height="match_parent" />

android:id="@+id/the_frag"
android:layout_width="match_parent"
android:layout_height="match_parent" />

The code for the Fragment subclass referred to in the layout in main.xml is below.

package com.my;

import android.app.Fragment;
import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;

public class FragmentExample extends Fragment {
private int nAndroids;

public FragmentExample() {
}

/**
* Constructor for being created explicitly
*/
public FragmentExample(int nAndroids) {
this.nAndroids = nAndroids;
}

/**
* If we are being created with saved state, restore our state
*/
@Override
public void onCreate(Bundle saved) {
super.onCreate(saved);
if (null != saved) {
nAndroids = saved.getInt("nAndroids");
}
}

/**
* Save the number of Androids to be displayed
*/
@Override
public void onSaveInstanceState(Bundle toSave) {
toSave.putInt("nAndroids", nAndroids);
}

/**
* Make a grid and fill it with n Androids
*/
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle saved) {
int n;
Context c = getActivity().getApplicationContext();
LinearLayout l = new LinearLayout(c);
for (n = 0; n < nAndroids; n++) {
ImageView i = new ImageView(c);
i.setImageResource(R.drawable.android);
l.addView(i);
}
return l;
}
}

package com.my;

import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.AdapterView.OnItemClickListener;

public class FragmentExampleActivity extends Activity implements
OnItemClickListener {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

ListView l = (ListView) findViewById(R.id.number_list);
ArrayAdapter numbers = new ArrayAdapter(
getApplicationContext(), android.R.layout.simple_list_item_1,
new String[] { "one", "two", "three", "four", "five", "six" });
l.setAdapter(numbers);
l.setOnItemClickListener(this);
}

/**
* Add a Fragment to our stack with n Androids in it
*/
private void stackAFragment(int nAndroids) {
Fragment f = new FragmentExample(nAndroids);

FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.replace(R.id.the_frag, f);
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
ft.addToBackStack(null);
ft.commit();
}

/**
* Called when a number gets clicked
*/
public void onItemClick(AdapterView parent, View view, int position, long id) {
stackAFragment(position + 1);
}
}

This is what you see when you when you run the program: Initially, you see a list of numbers, and a blank area to the right.

Touch a number, and a new Fragment is created, with the specified number of Android icons. If you keep touching numbers in the list on the left, the corresponding number of Android icons appears in the Fragment instance on the right. Now try the back button. Instead of returning to an instance of the Activity that was on the screen before this application launched, you see the previous Fragment instance on the right. That is, the Fragment objects have been integrated into the task’s back stack.

Fragments are a new feature of Android, and this brief example only scratches the surface of how Fragment will change the way Android UIs are implemented. You can see from this example that using Fragments is efficient and expressive.
You can read more about Fragment, and how it can be used alongside starting Activity objects to drill into detail views in an Android UI in an article by Dianne Hackborn, here.

Download source code FragmentExample [19kB]

Android versions

W.Elsinga — Mon, 21 Mar 2011 01:24:27 +0000

Google’s Android division certainly has a sense of humor as it named all their version codenames after desserts. So what are the different versions of Android OS, and the desserts associated with them?

Noname 1.1 version
There appears to be no codename assigned to Version 1.1 of Android OS. An update of Android, version 1.1, was released in February 2009.
Android 1.5, a.k.a. Cupcake
The first significant version of Android OS that really showcased the power of the platform is V1.5, codename “Cupcake”.
Android 1.6, a.k.a. Donut
Android V1.6, codename Donut, was released in September 2009.
Android 2.0 / 2.1, a.k.a. Eclair
Android V2.0 was released in October 2009, with a bugfix version 2.0.1 in December 2009. Android V2.1 was released January of 2010.
Android 2.2, a.k.a. Froyo
Android V2.2 was released in June 2010.
Android 2.3, a.k.a. Gingerbread
Android V2.3 was released in October 2010.
Android 2.4/3.0, a.k.a. Honeycomb
Is not out yet

A closer look at Android 3.0 (Honeycomb)

W.Elsinga — Mon, 21 Mar 2011 00:32:15 +0000

Google has released its Android 3.0 (Honeycomb) software development kit (SDK) preview, allowing mobile developers to get an early hands-on with what the first tablet-only version of the Android operating system has to offer. So let’s take a closer look

For Testing Only

The SDK offers non-final APIs and is for testing purposes only.
Google says its release is intended to allow developers time to familiarize themselves with the new UI patterns, APIs and capabilities. One thing I have notist, it’s extremely slow. If you’re just curious about its insides and don’t need to test anything yourself, it may be better to just stick with the news and forum postings for now

Honeycomb for Users

The new features for users in Honeycomb are detailed on the Android Developers website. To summarize, those are as follows:

System Bar: The notifications bar from the Android phone has been transformed into a “System Bar,” which now lives at the bottom of the screen. From here, you can access notifications, system status and the soft navigation buttons (Back, Home and Recent Apps).
Action Bar: The Menu area from Android phones has become the Action Bar on Honeycomb. Now at the top of the screen, this bar provides access to the contextual options, navigation, widgets and other content, as dictated by the application currently running.
Customizable Homescreens: Honeycomb comes with five customizable homescreens which users can add widgets, app shortcuts and wallpapers to. Each homescreens offers a launcher for access to all the applications and search box for apps, contacts, media files, Web content and more
Recent Apps
New Keyboard: Honeycomb’s soft keyboard offers reshaped keys which have been repositioned for better targeting. New keys, including Tab for example, have been added, too.
Better Copy-and-Paste: The copy/paste functionality has been given an upgrade too.
Connectivity Options: Honeycomb offers built-in support for the Media/Photo Transfer Protocol, which lets you sync with a USB-connected camera. You can also attach USB or Bluetooth keyboards. Bluetooth tethering is supported and Wi-Fi connectivity has been improved.
New Standard Apps: Also new in Honeycomb are major updates to the standard Android applications, the Browser, Camera and Gallery, Contacts apps and Email.

Honeycomb for Developers

Developers need to be aware of the following features:

UI framework for creating great apps for larger screen devices
High-performance 2D and 3D graphics: A new property-based animation framework lets developers add great visual effects to their apps. A built-in GL renderer lets developers request hardware-acceleration of common 2D rendering operations in their apps, across the entire app or only in specific activities or views. For adding rich 3D scenes, developers take advantage of a new 3D graphics engine called Renderscript.
Support for multicore processor architectures: Honeycomb is optimized to run on either single- or dual-core processors, so that applications run with the best possible performance.
Rich multimedia: New multimedia features such as HTTP Live streaming support, a pluggable DRM framework, and easy media file transfer through MTP/PTP, give developers new ways to bring rich content to users.
New types of connectivity.
Enhancements for enterprise: New administrative policies, such as for encrypted storage and password expiration, help enterprise administrators manage devices more effectively.

Source Readwriteweb..com
Source Developer.android.com