Developers rejoice! One of my favorite Android libraries to date has recently been upgraded to becoming evenmore awesome than before. Jake Wharton’s ActionBarSherlock library has been updated!

ActionBarSherlock is an extension of the compatibility library designed to facilitate the use of the action bar design pattern across all versions of Android with a single API.  It allows the easy addition of the action bar Android UI paradigm to applications without having to worry about compatibility with older versions of Android.  I am a strong supporter of this paradigm and try to use it whenever possible!

From his Google Plus:

Major updates in this version:

• Completely redone menu and action item support. This has been backported from the progress made on ABS 4.0 and provides a much more stable and logical layout of action items and management of the menu.
• The compatibility library base has been updated to r6. I have also re-added the *Compat classes that were duplicated by this library and marked them as deprecated.

Download the new version from http://abs.io/. The samples on GitHub and the Android Market will be rolling out this evening as well.

Updating your projects making use of the old library is ridiculously easy.  Just download the new library and any desired .jar files, add the library as a project to your eclipse setup, and replace the references in your project to the old libraries with references to the new libraries.

Do you have any experiences using the ActionBarSherlock Library?  Would you like to see a guide for how to get up and running on ActionBarSherlock?  Drop us a comment below or tweet us @droidweb!

In Part One of Starting Android Development, we discussed setting up your project in Eclipse.  Now it’s time to explain exactly what’s going on and how Android development works.  This information will help you keep things in perspective as you program, and it will help you when it comes to debugging time.

Let’s take a look at the Eclipse screen after you’ve set up a given project:

For the purposes of this explanation, let’s look at the directories in the left pane of the Eclipse screen.  Under the name of the project you’ve just created, you should see several subfolders.  Let’s explain what they do:

• src: This holds the source code for your project.
  • com.droidweb.conversion: This is the package holding your source code.  Several packages can make up a single project.  This is especially true when you include others’ packages to provide some type of functionality for your program.  For example, in a conversion application I wrote (ConvertAll+), I imported a package to handle different currencies.
    • convert.java: Inside the package are individual .java files.  This is where the goodies (the source code itself) are.
• gen: This is a folder for automatically generated stuff Android uses to help your program operate properly.  There’s nothing in here that you need to mess with.  It will automatically update itself as necessary.  Sometimes when you import projects and they return errors, the solution is to delete this folder and let Eclipse regenerate it for you . . . but more about that later.
  • com.droidweb.conversion: This is the package holding automatically generated code corresponding to the package of the same name in the /src/ folder.
    • R.java: R.java is an automatically created and maintained file that keeps up with the resources your project utilizes.  In a lot of your Android programming, you’re going to use static variables that really translate into numerical (usual hex) values.  R.java makes the translation between these variables and their numerical values.
• Android 1.5 (or appropriate Android source version): This contains the actual Android source code on top of which you’re going to build your applications.  As such, I’m not really going to discuss this much.
• assets:  Why, this is what you set your — oh wait — wrong thing. . . . Usually you won’t mess with this folder, but if you have raw files to be read by your application, then they can be put here; but it’s probably better that it goes in the /res/raw folder.  More about that later.
• res: res stands for resources.  Here is where you put your resources (images, files, etc).
  • drawable: This is where the images you’re going to use go.  Android supports a variety of image files, including .jpg, .gif (static), png, etc.
  • layout: This is where the .xml files describing your program layouts go.  I’ll spend a post on those later.
  • values: This is where .xml files defining values can be stored.  An example is a network topography program I worked on.  In the custom view drawing routine, I predefined the colors of good / bad links in a .xml file in the /srv/values folder.
• AndroidManifest.xml: This is the file that will be the source of the most headaches for you (well, starting out it will be . . .).  This is where your project is described in a form that Android devices can understand.  Application permissions, activity descriptions, and more are found here.  This file itself will be the topic of a future post onto itself — yes, it’s that important.

Next time we’ll discuss program flow in a typical Android program.

So, you’ve got an Android Device.  You’ve got the SDK set up.  Now what?  In the next few posts, I’m going to walk you though creating your very own Android application from scratch.

To do that, I’m going to assume the following:

• You have your Android SDK setup
• You know a little something about programming in Java
• You’re willing to leave comments if some of my instructions are unclear

All right . . . ready to start?

Setting up a new project in Eclipse
Each program you write for Android will be contained in its own ‘project’ from Eclipse’s point of view.  This makes sure that the code is stored properly in its own little folder.

• Select File > New > Project
• From the resulting wizard, chose Android > Android Project (See picture below)

• The next screen will allow you to set up most of the important values that Eclipse needs.  Here’s a quick explanation on what they mean:
  • Project Name: This is the name that the project will have in your workspace.
  • The Contents box determines where the source files (your .java, .dex, and other files) are going to be stored.
  • The Build Target box allows you to select which version of Android you’re shooting for.  Since I’m using some old code for this project, I’m going to use Android 1.5 as the target — meaning that this program will theoretically run on all Android devices 1.5 and above .  As of right now, I build most of my projects to run on 1.5 / 1.6 and test for all versions of Android that are out there on devices (1.5 / 1.6 / 2.0).
  • Application Name: Give your application name here.  This will be stored under a special variable that we’ll see later.
  • Package Name: Java code is organized in packages.  Enter a package name here.  The package name will lend itself to the folder hierarchy in which source code is stored.  For example, a package name of com.droidweb.temperature means that the code will be stored in com/droidweb/temperature/.
  • Create Activity: Android program flow is controlled by activities.  Check the box if you want a default activity to launch when your program opens (99 times out of 100 you do), then give it a name in the text box.  See the picture below if this is unclear.
  • Min SDK Version: This will automatically fill in based on your Build Target chose.  This is the minimum SDK version code on which your program will run.  Each version of the Android SDK has a version number as outlined in the table below:

Click Finish once you’ve filled in all the appropriate information.  Stay tuned for our next post: I’ll begin to explain the structure of your Android project.

That being said, I’ve found a way to upload and sync a large contacts book to the Android emulator.  The crux of the process makes use of Funambol, who “provides open source MobileWeb push email and pim sync software for billions of phones,” and their sync application for Android.  To install and use this program perform the following steps [I suggest reading entire instruction set before starting]:

• Download the Funambol sync .apk file to your phone.
  • Open an android emulator.
  • Open the included browser in the emulator
  • Navigate to https://android-client.forge.funambol.org/
  • Click on “Documents & Files” under the Project Tools menu

• • On the resulting screen navigate through the file structure as follows:
    • Android Client (0,6) > Contrib > (0,1) > a la Mobile

• • Select alamobile-Funambolsync.apk [<—Or just click on this link via your emulator] and download
• Install Funambol .apk file
  • Install as you would any .apk file

• Setup Funambol Sync
  • Run Sync from emulator

• • Go to Menu > Settings

• • Enter credentials of Username: guest and password: guest
  • Click ok and click twice on contacts menu item to sync with Funambol’s sample address book.  The syncing process will take a few minutes as it seeds your contact book with 300+ entries.

• If your contacts don’t show up right away go to Contacts > Menu > Display Group > All contacts.
• Have fun!

1. Find out where your AVDs (Android Virtual Devices) are located.
   • This can be done by using the command

   android list avd

   • The command android is found within the /tools directory of the SDK you’re using.  Set this directory as a global $PATH variable for simplicity as per installation instructions here.
   • This will return a list of AVDs and their location

1. Now that you know where your emulator(s) are, navigate to the avd_name.avd/ folder.
2. Create the SD Card emulator using the mksdcard command

mksdcard 32M sdcard.img

To add files to the SD Card, go to Eclipse and select the DDMS view.  From there select your emulator.  Click on the file browsing tab.  Here you can drag and drop things to the /sdcard/ folder.  Enjoy