This process is very similar to the one regarding the Gingerbread, so I suggest you skim through that post.

You can read more about whats new in Honeycom here. And here is more about the Honeycomb preview SDK itself.

First, we need to open our Android SDK and AVD manager, and install the new Honeycomb packages:

1. Go to Available packages and Select Android SDK Tools and SDK platform Android Honeycomb Preview.

2. When they are downloaded and finished installing, restart your SDK and AVD Manager.

3. Go to Available devices and hit New to create the new AVD for Honeycomb.

4. Give your AVD a nice name, and select Honeycomb (3.0) from the dropdown list. Hit Create AVD.

5. Now select your AVD, and hit start.

Note: It takes some time to start the AVD, and for me, it was a very slow experience navigating around, but it gives a nice introduction to honeycomb.

I took some screenshots from my AVD:

Note: If you are using Eclipse, there is also a new update to the Eclipse ADT (version 9.0.0), so you should update. It seems they have fixed the XML formatting.

My AVD device started up in a horizontal orientation, if yours do that too, you can easily change the orientation of your Emulated device.

Please share this article.

Say, if you follow that guide, and have made an icon to represent your app, how do you use it?

If you have one icon image, or three icon images (one for each screen density, ldpi, mdpi and hdpi, like in the guide), you put your icon files in the res/drawable folder where they belong.

Depending on what API level you are creating your Android application for, in your “res” folder you either have one folder called “drawable” or three folders called “drawable-ldpi”, “drawable-mdpi” and “drawable-hdpi”.

For application launcher icons, the sizes are:

• Low density – ldpi – 36×36 px
• Medium density – mdpi – 48×48 px
• High density – hdpi – 72×72 px

When you have put your icon in the folder/folders, open up your AndroidManifest.xml file and choose to view it as XML.

For a new Android application, the AndroidManifest.xml file will look like this:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="test.application"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".YourAppName"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

And on line 6 you can see the attribute that specifies your applications icon:

android:icon="@drawable/icon"

The /icon refers to the default icon.png file in your drawable folder (or the drawable-ldpi/mdpi/hdpi folders).

If substitute “icon” with the name of your icon file, you will change the icon of your app.

Using this method we can easily skip through the difficult and time-consuming parts of creating icons.

Yes, I know this method does not work for everyone, some Android developers have their own designer and so on, but for a small and simple app, this will definateley do!

The problem

Creating icons for Android apps may sound simple, but in fact, it is not as easy as it sounds…

There are a number of different icon categories, here are a couple of them:

• Launcher icons – The applications main icon
• Menu icons – The icons on the menu you get when pressing the menu button on your device
• Tab icons – Icons on tabs
• Status bar notification icons – Icons for your apps notifications

When creating icons for Android, you should create icons for different screen densities:

• Low density – ldpi – 36×36 px
• Medium density – mdpi – 48×48 px
• High density – hdpi – 72×72 px

(You can read more about the different icon dimensions here. Note: The dimensions in bold above, are for menu icons)

The Problem: Creating all those different icon types in several densities, with the right gradient color, shadow, borders, selected/unselected state etc, can be a time-consuming and irritating process.

We would like to save us some time!

The solution

So if you just need a basic icon, heres a much simpler way using the Asset-Studio, which is part of the android-ui-utils, which aims at helping developers with Android apps UI. Chrome is the recommended browser to use on the Asset-Studio site.

This method also uses free tools, so you don’t need Illustrator.

The basic procedure to create an icon is:

1. Use Inkscape (GPL license) to create your basic icon shape, then export it
2. Upload your icon to the Asset-Studio website and make adjustments if needed
3. Download zip of finished resources from the website
4. Copy paste into Eclipse project folder

You can then use your icon in XML or Java code as usual, enjoy your new icons!

Here is an example of how to create a menu icon using the four steps above:

1. Creating a menu icon in Inkscape

1. I assume you already have Inkscape up and running
2. Create a new empty document
3. Go to File -> Document Properties, set the Document Width and Height to 72 px, then close the Document properties window. You now have a quadratic starting point, as big as the High density image needs to be, this way we avoid scaling the image up
4. Create your awesome icon, stay inside the frame, try to make it smooth, not to many hard corners. I have not used Inkscape before, so I just made some basic shapes and used Path -> Difference to get my icon:
   

   Nice huh?

5. In Inkscape go to File -> Export Bitmap, and select “Page”, it should look like this:

You now have a .png file ready to upload to the website.

You can download (Right click -> Save as) and use my star icon freely if you want to.

2. Using the Asset-Studio

1. Go to the Asset-studio website, select Menu icons
2. For the source: Click on the Image button to browse and upload your icon file (.png) (supported images are jpg, gif, png, svg and a couple others, only the png file worked for me)
3. Set the trim and padding to what you see fit in the frame
4. Give your new resource a name in the “Icon name” field
5. Select Download zip on the bottom of the page

3. Getting the icon into your Eclipse Android project

1. The downloaded zip with the name ic_menu_star.zip (your name may differ), contains a res folder, with three folders: drawable-ldpi, drawable-mdpi and drawable-hdpi, including the icons in different densities, with gradients, shadows and everything in place (magic!).
2. Just copy the icon from the res/drawable-hdpi in the downloaded zip, into the res/drawable-hdpi folder in your Eclipse Android project, and do the same with the mdpi and ldpi icons

4. Using the icon in my Android app

The simplest usage example of a menu with 2 items:

package test.layout;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class LayoutTest extends Activity {

	private final int MENU_STARS = 1;
	private final int MENU_REFRESH = 2;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
    public boolean onCreateOptionsMenu(Menu menu){
    	boolean result = super.onCreateOptionsMenu(menu);
        menu.add(0, MENU_STARS, 0, "Stars").setIcon(R.drawable.ic_menu_star);
        menu.add(0, MENU_REFRESH, 0, "Refresh").setIcon(R.drawable.icon);
    	return result;
    }

    /* Handle the menu selection */
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case MENU_STARS:
            showFavourites();
            return true;
        case MENU_REFRESH:
            refreshData();
            return true;
        }
        return false;
    }
    public void showFavourites(){
    	//your code here
    }
    public void refreshData(){
    	//your code here
    }
}

This code uses the icon we created above and put into the drawable folders, and the default icon that comes with every new Android project, just for demonstration, also located in the drawables folders.

The applications menu will look like this:

Code explanation:

1. Implement onCreateOptionsMenu, which creates the menu when a user presses the menu button on his device
2. Implement onOptionsItemSelected, which takes care of the logic when a user presses one of the menu items
3. The final variables are each used to represent a menu item, and gives a human readable name to each of them
4. The two last methods are executed when a user presses the respective menu item

Similar steps can also be used to create Launcher icons, Menu icons, Tab icons and Notification icons via the Asset-Studio website. And you can read up on how to create the different types of menus here.

I hope this helped many people save a good amount of time and frustration!

Please share this article.

We are going to create gradients like these:

Nice green gradient lines...

About Drawables

First off, we are going to create a drawable. A drawable resource is graphics that can be drawn on the screen,
it can be a couple of different things, here are some examples;

• Bitmaps – png, jpg or gif images
• Nine-Patch image – A png that can be stretched, to create buttons of varying sizes for example
• State List – Making it easier to use different images for button states for example (focused, pressed)
• Shape Drawable

You can read more about drawable resources here.

Creating a Gradient Shape Drawable

In this example we are going to use the Shape Drawable, with it, we can create different shapes, we will use a Rectangle shape.

Create a new .xml file in your drawable folder (or drawable-mdpi folder) called gradient.xml, with the following code:

<?xml version="1.0" encoding="utf-8"?>
<shape
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:shape="rectangle">
	<gradient
		android:angle="0"
		android:startColor="#000000"
		android:endColor="#000000"
		android:centerColor="#97CF4D" />
</shape>

And that is basically it. You now have a gradient ready to use.

How to use our Gradient Shape Drawable file

In your layout file (main.xml for example), enter the following code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:id="@+id/LinearLayout01"
	android:orientation="vertical"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent"
	android:padding="10dp">

	<Button
		android:text="Button"
		android:id="@+id/Button01"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"></Button>
	<View
		android:layout_width="wrap_content"
		android:background="@drawable/gradient"
		android:layout_height="1dp"></View>
	<CheckBox
		android:text="CheckBox"
		android:id="@+id/CheckBox01"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"></CheckBox>
	<View
		android:layout_width="wrap_content"
		android:background="@drawable/gradient"
		android:layout_height="1dp"></View>
</LinearLayout>

If you look at the View widget on line 15-18 and 24-27, that is how we use our gradient drawable.

The android:background=”@drawable/gradient” uses our newly created gradient.xml file in the drawable folder (or drawable-mdpi folder), and the result you can see on the first image!

Please share this article.

It took me a little research before I found a solution, so I will share two methods with you today.

This tutorial will show you how to create layouts that stretches in the width.

In Eclipse I create a new Android Project by going to File -> New  -> Other -> Android -> Android Project. The default project just using the main.xml file for these example layouts will do just fine.

We can create a stretching layout with two different methods; Layout Weights and Layout Spans, I will show a simple example of both, and then I will show how to center an element in a TableLayout with Layout Spans.

Stretching layout using Layout Weights

About Layout Weights

Simply put, layout weights are a way of defining how much of the layout space a widget element will take.

It can be thought of as a percentage of layout space, but it is written 0.2 instead of 20%. So if you want to give an element a size of roughly 20%, you set android:layout_weight=”0.2″ for that element. (These percentages/weights are not exact values, a layout_weight of 0.1 may on your phone turn out to look more like 0.05 or 0.15)

Creating a simple layout with one EditText and one Button

The following code (download) will give a simple layout using LinearLayout, and stretch both the EditText and the Button to fill the width.

If you replace your main.xml files content with that code, save, and run it, the layout will look like this on your virtual device:

Stretching layout using Layout Spans

In this example we are going to use a TableLayout with one TableRow containing one EditText and a Button.

The amount of space given to each element, is specified in the android:layout_span attribute, which tells us how many columns it will span over.

The example code (download) looks like this:

• The asterix (*) on line number 6 says that all columns should be stretched
• We see on line 14 that the EditText has a layout span of 4 columns
• On line 21 we see that the Button has layout span of 1 column
• In total that is 5 columns in our TableLayout.

1/5 is 0.2, so the Button should take about 20% of the space, as we can see in the picture below:

How to center an element in a TableLayout

This is another example using Layout Spans and TableLayout. It just demonstrates how you could place elements with the use of the android:layout_span attribute. It also shows how to centre elements in a table, which is very handy.

The code (download) looks like this:

And the resulting layout looks like this:

Explanation:

• The Heading spans over 3 columns, and is centered over these columns by the gravity attribute
• Text 1,2 and 3 span over one column each
• Text 4 span over 2 columns, while Text 5 gets the rest, which is 1 column.
• On line 6, the asterix (*) says all columns are set to stretch.

Please share this article.

• Updating Eclipse ADT
• Installing Android SDK updates
• Creating the AVD

Gingerbread comes with lots of new nice features and improvements, you can read about them here. Or you can watch the official video, to get a quick overview:

Altough testing the OS in an AVD, does not compare to the real device in terms of speed and awesomeness, It is the closest you can get right now.

Getting Android 2.3 up and running on your computer is an easy task, I previously created a very simple-to-follow tutorial how to get started with Android development. Installing Android 2.3 is much the same thing, so I assume you are coming from that guide, or already has a development environment set up.

Here is what we need to do:

• We must first update our Eclipse ADT.
• Then we must install SDK updates in our SDK and AVD manager.
• We then create a new AVD with Android 2.3, and run it.

If you dont have ADT or a development environment set up yet, you can follow the tutorial I wrote earlier.

Updating Eclipse ADT

To update our development tools, go to Help -> Check for updates in the Eclipse menu.

Installing Android SDK updates

Go to the SDK and AVD manager in Eclipse: 

Click the Install selected button, to install the updates for Android 2.3 (API 9), (see the image).

On the next screen, select accept all.

When installation is finished select restart adb, when that says Done click close.

Verify: To verify that the AVD indeed has been installed (at first, It wouldn’t install when I tried):

Check the installed packages menu in the AVD manager, hit refresh, and see in Android 2.3 (API 9) is installed.

If it is not, go back to “Available packages” and hit refresh, select and install Android 2.3 (API 9) again.

Creating the AVD

So, open the AVD manager, select Virtual devices and New…

Give your Android 2.3 device a suitable name, resolution, SDCard space, and then hit “Create AVD”.

It then gets added to the AVD list, select it in the list, and hit Start and then Launch.

After a long time of loading, the AVD is up, and you can go mad and test Gingerbread already!

Note: The Gingerbread AVD seems to be quite slow, even slower than a Froyo AVD.

• Downloading tools
• Installing the tools
  • Java
  • Android SDK
  • Eclipse
  • Android Development Tools (ADT)
• Configuring
  • Configuring the ADT plug-in
  • Installing an Android Virtual Device
• Final words…

The reason for using Eclipse is because there exists an Android development plug-in for Eclipse, which makes things easier for us developers. Also, Eclipse is a good and Open Source IDE. Eclipse can also be used for other languages such as PHP, C++ and Ruby, it also has a very good Subversion plug-in for using repositories.

Developing Android applications, and using these tools described here, does not cost you anything.

Some short explanations

• Java JDK: This is a collection of Java development tools
• Android SDK: This contains a bunch of development tools.
• AVD: AVD stands for Android Virtual Device, and is a device you can use to test your applications on.
• ADT: Android Development Tools is a plugin for Eclipse, which makes developing Android applications much easier. With this plug-in you can easily create new android projects, create GUI for your application, manage internationalization, debug your application, and testing you app on your AVD, or directly on your real device.

We will first need to get a couple of tools, before we install the tools, and configure them properly.

Downloading tools

First off, if you don’t have Sun Java JDK installed already, go ahead and download it.
Use the 32 bit version, as pointed out in the comments below.

Then download Eclipse IDE for Java Developers from here.
(I am running 64 bit Windows 7, but I use the 32 bit Java SDK and Eclipse versions since that works best together)

Then get the android SDK for Windows from here.
The current filename is android-sdk_r07-windows.zip.

And that’s all the tools we need.

Installing the tools

I would recommend installing tools like these to a folder that has a path without spaces in it.
I have created a directory called C:\dev for my Android development, so I will install Eclipse and the Android SDK into that folder:  C:\dev\eclipse and  C:\dev\android-sdk-windows

Java

First install Java JDK, which also will install Java JRE.

Create a new environment variable to point to where you installed Java JDK.
The default JDK location is C:\Program Files\Java\jdk1.6.0_22

Go to Control Panel ->Advanced system settings -> Click the Environment Variables button

Choose the PATH variable, click Edit, and add the location to you JDKs bin folder, at the end.

In my case that is:   ;C:\Program Files\Java\jdk1.6.0_22\bin

Remember to add  the ; to separate this path from the other paths.

Then hit Ok and Ok.

To verify that Java was installed correctly, open a command window and run this command:  java -version

And you should see something like java version “1.6.0_22″ etc… Then you know the installation was successful, and we can continue.

TIP: to set the JDK bin path in the PATH variable, you could also run this from a command window:
path = %PATH%;C:\Program Files\Java\jdk1.6.0_22\bin
Then close the command line window, open a new one, and test with the command: java -version

Android SDK

To install the Android SDK, simply unzip the file to you C:\dev folder, or any other folder of your choice.
I put my SDK in my dev folder, so the path to it becomes C:\dev\android-sdk-windows

You can add the tools directory in your SDK folder to your PATH variable (like we did above) to get easy command line access to various tools.

Eclipse

To install Eclipse, simply unzip the .zip file. I put Eclipse in my C:\dev\eclipse folder.

Android Development Tools (ADT)

The ADT is a plugin for Eclipse, we can install plug-ins with Eclipse’ own plug-in manager, so start Eclipse.exe

First time you start Eclipse, you can select a workspace, Eclipse uses the workspace to store your android projects, plug-ins etc.  I like to know where I find this folder, so I put it in my dev folder.

You now have Eclipse running, and we need to install the ADT plug-in.

In the menu bar, go to Help -> Install new software

(or Software updates if you have Eclipse 3.4)

Enter the location where to download the ADT from, which is

https://dl-ssl.google.com/android/eclipse/

And hit enter,  you should now see the Developer Tools in the list below. Check all of them and hit Next.

On the next screen for reviewing your updates, hit Next. On the next screen with licenses, accept, and hit next.

After a little while you get a message that says

“Warning: You are installing software that contains unsigned content….” Hit Ok.

When the installation is finished, hit Restart Now.

Tip: Sometimes the ADT plug-in gets updated, you can install those updates by going to the Check for updates under the Help menu And then check Android DDMS and Android Developer Tools if any updates are available.

Configuring

After installing our tools, we need to configure them properly.

Configuring the ADT plug-in

Now we need to show the ADT plug-in where we installed our android SDK.

In the menu  bar, hit Window ->Preferences, and go to the Android tab.

Now browse to the location of where you installed the SDK, mine was C:\dev\android-sdk-windows.

Hit Apply, and OK.

You now (hopefully) have your Eclipse IDE set up right, and we are ready to start developing. But first, we need an android device to deploy and test our applications on.

Installing an Android Virtual Device

Hit the little box with a green android in it in the Eclipse menu bar , this launches the Android SDK and AVD Manager.

Under Available packages, you can choose which device you want to test your applications on.
For example API7 is Android 2.1.

Check the API7 packages, Usb driver package, Market licensing package, and the samples, and hit the Install selected button

On the next screen, check Accept all and hit Install

The download may take a couple of minutes depending on your internet connection.

When it is finished, select Restart Eclipse and then Close.

Close the AVD manager and restart Eclipse.

Open Window -> Preferences -> Android, and make sure an SDK Target is selected in the list, otherwise choose “Android 2.1-update1″, Hit Apply and OK.

Open the Android SDK and AVD manager , and then the Virtual devices menu.
You have earlier downloaded the files for the android virtual device, now it’s time to install it.

Hit New, Enter a name for your device, and choose the android 2.1 API 7 that we installed.
You may give it a couple of MB SD Card storage too.

Then hit Create AVD. We now have an AVD installed, if you want to launch it, select it, hit Start… and then Launch.

It always takes some time to start the AVD, but when it is booted, you should see this:

Final words…

You are now ready to begin developing android apps!

Thank you for following this tutorial.

If you want to try out the new Gingerbread (Android 2.3) AVD, you can check out this similar guide on how to get it up and running!