Getting Started with Android Development

If you're new here, you may want to subscribe to my RSS feed or follow me on Twitter. Thanks for visiting! Note from Ray: Although this site has been focused on iOS development so far, I thought you guys might enjoy learning a bit about Android development as well. So iOS tutorial team member Ali Hafizji has put together this great tutorial on Android development for beginners! I had never programmed for Android before, but bought myself a device and used this tutorial as my first introduction to the platform. Now that I have a simple app running on my device Im excited and eager to learn more, and I hope you guys will feel the same way! :]

Learn how to make this simple master/detail Android app!

This is a blog post by iOS Tutorial Team member Ali Hafizji, an iOS and Android developer living in India. Since Ive been following this blog, Ive never read a post related to Android application / game development. So I thought writing something in that area would be helpful to any beginner :] Android is an amazing and fun platform to work on. Anyone can come up with their own unique idea, create a good product and make it available to thousands and thousands of customers. In this tutorial, we will create a Hello World Android app, get it working on the emulator or a device if you have one, and create a simple master/detail app that shows a list of quotes by our favorite hero, Steve Jobs. Ill even show you how to build the app for distribution on the Google Market!

And yes, it is a little ironic to make a Steve Jobs quote app on an Android device, but hey this is mainly an iOS blog after all ;] So keep reading to dive into the wild world of Android!

So Many Devices!
Anyone who wants to buy an android device has a large variety to choose from. There are more than 300 android devices in the market each with their own hardware features. If your primary concern is development, get the best phone that matches the lowest API level that you wish your software to support, so you can test with it. Use the emulator to test other API levels. If your primary concern is having a good phone, get the best phone and use the emulator to test other API levels. For app development, it doesnt really matter which phone you get aside from API levels, for game development you might want the slowest phone that you intend to support so you are forced to write efficient code. Considering all this if you want to buy a phone for software development I recommend buying the Samsung Galaxy Ace, Htc Wildfire S, or Motorola Droid X2. Any should meet your development needs, and you can pick up a fairly inexpensive used one from the links above. However if youre looking for the latest and greatest, I recommend Googles new Galaxy Nexus. This just came out in December and is one of the most powerful devices out there, and is running the latest version of Android (Ice Cream Sandwich). Note from Ray: I ended up purchasing a used Motorola Droid X2 for about $150. I chose this device because I wanted something cheap for testing purposes, and didnt want to pay a monthly contract. I hooked up the phone to my local Wi-fi network (bypassing the activation screen by tapping the upper left, upper right, bottom right, and bottom left of the screen where it says to tap the android). I was successfully able to use this device to go through the tutorial.

Setting Things Up
Before we start with the installation process first verify that your computer meets the basic system requirements. If youre on a mac like me make sure you have Mac OS 10.5.8 or later (x86 only). Step 1: Verify JDK is installed The first step is to check if you have the JDK (Java development kit) installed. Macs usually come with the JDK preinstalled and ready to use. To check what version of the JDK you have open up a terminal and type in the command which java. Go to the directory that is printed and enter the command java version. Here is what the output looks like:

If for some reason you do not have Java installed, you can download and install it from Oracle.com. Step 2: Download Eclipse

The next step is to download eclipse (the classic version is recommended). You can download it fromhttp://www.eclipse.org/downloads Step 3: Download the Android SDK You can download the Android SDK from http://developer.android.com/sdk/index.html and unpack it. Note you may want to put your Android SDK in a safe spot since youll be using it a lot. Once done, go to the tools folder and double click the android executable. This will open the Android SDK and AVD manager. Step 4: Download Packages Click on Available packages this will show a list of all the available Android SDKs. Download an SDK that you want to build your app for. To choose an SDK based on your device, go to Settings\About phone\Android version to see the version your phone is running. Then choose an SDK that is the same version as your device or earlier. Step 5: Install ADT plugin Next we need to setup the ADT plugin. To do this start eclipse go to Help > Install new software. Click Add on the top right corner

Enter the following URL: https://dl-ssl.google.com/android/eclipse/ Check developer tools, click Next, and walk through the wizard to install the tools. After you restart Eclipse, it will prompt you for the Android SDK installation directory. Select Use existing SDKs and browse to the directory where you downloaded the Android SDK, and finish the wizard. Thats it! You have successfully setup your development environment. Note: Some of the above steps may not work if youre not a Mac user. If thats the case please find the detailed steps here: http://developer.android.com/sdk/installing.html

Hello Android!!

Assuming you have successfully installed everything, its time to create your first android project. Step 1: Creating the project

Start eclipse Go to File > New > Other > Android and select Android Project. You should see the following popup screen (yours may be slightly different or split into several steps):

Enter all the details as I have. Here is a brief explanation of each field:

Project name is the name of the directory that contains the project files (name it QuoteReader because thats what well make).

Build target specifies which version of Android the application is built for. Ive selected 2.2, which is Froyo.

The properties elements are self explanatory except for the MIN SDK property. This is used for backward compatibility i.e. if your application requires a minimum api level, or is designed only to support a certain range of Android platform versions. Setting this to a

value ensures that your application can only be installed on devices that are running a compatible version of the Android system. Okay! Now that you have entered all the details press next. Eclipse will now create the project, which you can see in your project navigator. Step 2: Understanding the project structure Before we get started with any code lets spend some time going through the project structure.

Here is a brief description of the folders present:

Source (src): This folder contains all the source files i.e. this is where all the code is. Res: This is the area where you keep your images, strings and xml layouts. Assets: This is another place where you can keep files. The difference between /res and /assets is that Android does not generate IDs for the assets. What this means is that to access a file in assets the developer has to provide a complete path to that file.

Now that you have a basic understanding of the project structure, lets run the application. Step 3: Running the application There are two ways in which we can run the application either on an actual device or on an emulator. I will explain how to do both very briefly. To run the application on the emulator we first need to create an AVD (Android virtual device). This is an instance of the android emulator. To do this, follow these steps:

Go to Window > Android SDK & AVD Manager and click New in the top right corner. Enter all the required details.

Click on Create AVD, after that you can start the emulator by just selecting it from the AVD manager and clicking on start.

After the emulator starts up you can run the application that you just created. To do this right click on the project, go to Run As and select Android Application. This will launch the app on the emulator.

Running the application on the device is fairly simple and requires very little effort. Here are the steps to launch an app on the device:

On your device, to to Settings\Application\Development and select the checkbox next to USB debugging.

Connect the device to your computer with a USB cable. Run the project through eclipse. You will see the following popup:

Select the device and youre app will be deployed.

Note: Notice that the popup above shows two options; the reason being I already have an emulator running hence I need to choose where to deploy the app i.e. either on the emulator or the device.

Creating a Simple and Easy App

The current state of the application is quite raw and we havent yet added anything to the default project. So lets try and build something small but useful. In this part of the tutorial we will build a tiny application. The idea is to build a quote reader. The quotes will be displayed in a list and when the user clicks on an item the app will navigate to a detailed page containing a picture and the quote. The first screen contains a list with quotes and thumbnails. Lets start by creating the UI for this. Step 1: Adding the list view If youre coming from the iOS development world, youre familiar with using Interface Builder to graphically layout an interface. However, because Android supports so many different devices with different screen sizes, creating user interfaces is completely different. Instead of visually dragging and dropping UI elements to a canvas, you need to define your UI in XML (yes, you read that right!). Youll add XML tags for the views you want (like buttons, labels, etc.) and add XML attributes for parameters like position, color, etc. Eclipse does come with a visual editor where you can drag drop UI elements, but I highly recommend editing the XML directly instead as this will give you a stronger grip over your view hierarchy. In this tutorial, well show you exactly what to input in the XML to set up the UI, but if you want to read about how it all works, check out Androids XML layout guide here. Now lets open the main.xml file from the res/layout directory. If the graphical layout view appears, select the main.xml tab to edit raw xml. Then replace the content with the following:

<?xml version="1.0" encoding="utf-8"?> <ListView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/quotes_list" android:layout_width="fill_parent" android:layout_height="fill_parent" > </ListView>

This will create a list view with a width and height equal to the size of the screen. Next we need to show this layout to the user, to do this open QuoteReaderActivity.java present in the source directory. You will notice that this class extends a class named Activity. In Android anything that the user interacts with is an activity, the activity is responsible for showing the user content which is present in different views. Notice that a method called onCreate is overridden and in it a method called setContentView is called. This sets the content of this activity with views present in the xml file passed to it.
@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); }

The R class present above is used to refer to the resources present in the /res folder. Heres a screenshot of the contents of this folder of this project:

The R class is automatically generated to contain properties for the resources that you put into this folder. For each type of resource, there is an R property (for example R.layout for all the layout resources) and for each resource of that type there is a static integer (for example R.layout.main). This integer is the resource ID that you can use to retrive that resource.

This is the xml file in which we just added the list view. Hence when the QuoteReader activity is started it will create our list view. Go ahead and run your application you should see a blank screen. This is because we havent yet added any rows to our list view. Step 2: Adding rows to the list In this step we will create rows and add them to our list. We know that the row needs to have a thumbnail and text. Here is how the row is going to look:

Lets start by creating the layout for the row. Create a new xml file in the res/layout directory and name it list_item_layout.xml. Open it in the raw XML view and replace the contents with the following:
<?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="100dip" > <ImageView android:id="@+list/thumb" android:layout_width="60dip" android:layout_height="60dip" android:layout_centerVertical="true" android:layout_alignParentLeft="true" /> <TextView android:id="@+list/text" android:layout_toRightOf="@+list/thumb" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textSize="18dip" android:layout_marginLeft="10dip" android:layout_centerVertical="true" android:singleLine="true" android:ellipsize="end" android:textStyle="bold" /> </RelativeLayout>

This creates an ImageView for the thumbnail and a TextView for the quote. Note that we give the ImageView and TextView an ID. An ID is used to uniquely identify a view within a view hierarchy. The syntax is funky here so lets explain it bit by bit:

The at-symbol(@): You put this at the beginning, and it indicates that the XML parser should parse and expand the rest of the ID string and identify it as an ID resource. The plus-symbol(+): This means that this is a new resource name and that must be created and added to our resources.

How to use: After the app is compiled you will be able to refer to this view using R.list.text.

Notice that the parent view used in this layout is a RelativeLayout. This layout allows you to position its children relative to each other and itself. The ImageView needs to be placed to the left of the layout and it needs to be centered vertically hence those properties are set to true. Also the TextView needs to contain text in a single line and if the length increases it should ellipsize, therefore the single line and ellipsize properties are set. Now that we have the UI in place, lets add some code so that we can use it for each list item. Step 3: Understanding adapters and data sources Okay lets take a brief pause and let me try and explain how a list view is populated with data. Data is present in something known as a data source this is the object that provides the data that will populate the list view. This is usually just a subclass of NSObject think of it as your apps model. An adapter sits between the data source and the list view. It provides the list with data from the data source and refreshes the list items when a scroll occurs. Android has two standard adapters, ArrayAdapter and CursorAdapter. You can also develop your own adapter by extending these classes or the BaseAdapter class. We will be extending the BaseAdapter class later on in this tutorial, but lets create the data source first. Step 4: Creating the data source First copy all the images that are provided here in your drawable directory. If you dont have a drawable directory, go ahead and create it. The drawable directory basically should contains items that can be drawn to the screen. The resources that you place here can be referenced through the R class. For example R.drawable.icon would refer a resource name icon in the drawable folder. Next, download the quotes well be using for the project and add them into your res/values/strings.xml file. The reason why I added strings to an xml file and not use them directly in code is because I like to keep my resources separate, also this helps a lot when youre localizing strings. Again you can refer the strings placed here using the same R class, for example R.string.quote_1 would refer the quote_1 string. Add the quotes to the file according to the following syntax:
<string name="quote_1">Innovation distinguished between a leader and a follower</string> <string name="quote_2">I want to put a ding in the universe!</string> <string name="quote_3">People don\'t know what they want until you show it to them.</string> <!-- add rest of quotes, up to quote_10 -->

Notice that you have to precede any single quotes with a backslash. Now that we have all the data, lets create our data source class. Right click on your src folder goto New and select Class. Name it DataSource, make sure the Package is set to whatever package QuoteReaderActivity.java is part of, and press finish. Add the following lines of code to it:
private ArrayList<Integer> mPhotoPool; private ArrayList<Integer> mQuotePool; private ArrayList<Integer> mPhotoHdPool; public ArrayList<Integer> getmPhotoHdPool() {

return mPhotoHdPool; } public ArrayList<Integer> getmPhotoPool() { return mPhotoPool; } public ArrayList<Integer> getmQuotePool() { return mQuotePool; } public DataSource() { mPhotoPool = new ArrayList(); mQuotePool = new ArrayList(); mPhotoHdPool = new ArrayList(); }

All that we have done here is create 3 variables, generated their getter methods, and initialized the variables in the constructor. If you get warnings that it cant find ArrayList, simply go to Source\Organize Imports to have Eclipse automatically add the import you need to the top of the file. You can do this same thing whenever you get warnings on missing imports later on in this tutorial as well. Next we need to populate the array lists with our data, which are the pictures and the quotes. Notice that we have defined our array list to contain integers. The reason for this is when you drop any resource into the resource directory the build system creates a unique identifier for it which is represented by an integer. Okay now lets create 3 separate functions to populate our ArrayLists. Add the following functions above the constructor definition.
private void setupPhotoPool() { mPhotoPool.add(R.drawable.steve_1); mPhotoPool.add(R.drawable.steve_2); mPhotoPool.add(R.drawable.steve_3); mPhotoPool.add(R.drawable.steve_4); mPhotoPool.add(R.drawable.steve_5); mPhotoPool.add(R.drawable.steve_6); mPhotoPool.add(R.drawable.steve_7); mPhotoPool.add(R.drawable.steve_8); mPhotoPool.add(R.drawable.steve_9); mPhotoPool.add(R.drawable.steve_10); } private void setupQuotePool() { mQuotePool.add(R.string.quote_1); mQuotePool.add(R.string.quote_2); mQuotePool.add(R.string.quote_3); mQuotePool.add(R.string.quote_4); mQuotePool.add(R.string.quote_5); mQuotePool.add(R.string.quote_6); mQuotePool.add(R.string.quote_7); mQuotePool.add(R.string.quote_8); mQuotePool.add(R.string.quote_9);

mQuotePool.add(R.string.quote_10); } private void setupPhotoHDPool() { mPhotoHdPool.add(R.drawable.steve_hd_1); mPhotoHdPool.add(R.drawable.steve_hd_2); mPhotoHdPool.add(R.drawable.steve_hd_3); mPhotoHdPool.add(R.drawable.steve_hd_4); mPhotoHdPool.add(R.drawable.steve_hd_5); mPhotoHdPool.add(R.drawable.steve_hd_6); mPhotoHdPool.add(R.drawable.steve_hd_7); mPhotoHdPool.add(R.drawable.steve_hd_8); mPhotoHdPool.add(R.drawable.steve_hd_9); mPhotoHdPool.add(R.drawable.apple_hd); }

Each of these functions is filling in data into our ArrayLists. Call these functions in the constructor like so:
setupPhotoPool(); setupQuotePool(); setupPhotoHDPool();

We will also add another function for the size of the data source. In our case the size of the data source is 10 i.e. we have 10 images and 10 quotes hence we can simply return the size of any one of our ArrayLists. Add the following function above the constructor:
public int getDataSourceLength() { return mPhotoPool.size(); }

Thats all we need. Next we need to use this data source and populate our list. Step 5: Creating the adapter Open QuoteReaderActivity.java from the src folder and create a private class, name it QuoteAdapter. This class should inherit from the BaseAdapter class and it should implement all the abstract methods with minimal implementations. Heres what the class should look like now:
public class QuoteReaderActivity extends Activity { public class QuoteAdapter extends BaseAdapter { @Override public int getCount() { return 0; } @Override public Object getItem(int arg0) { return null; } @Override

public long getItemId(int arg0) { return 0; } @Override public View getView(int arg0, View arg1, ViewGroup arg2) { return null; } } /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } }

Lets try and understand what each method does.

getCount(): Returns the number of items present in the data set. getItem(int position): Gets the data item associated with the specified position in the data set. getItemId(int position): Gets the row id associated with the specified position. getView( int position, View convertView, ViewGroup parent): This is used to get a view that displays the data at the specified position in the data set.

Now that we have a basic understanding of all the functions lets add a constructor to our adapter and some private variables. Add the following lines of code to the QuoteAdapter class:
private Context mContext; private LayoutInflater mInflator; private DataSource mDataSource; public QuoteAdapter(Context c) { mContext = c; mInflator = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE); mDataSource = new DataSource(); }

The only new variable here is the mInflator variable this is used to instantiate layout XML file into its corresponding View objects. Next change all the overridden functions as follows:
@Override public int getCount() { return mDataSource.getDataSourceLength(); } @Override public Object getItem(int position) { return position; } @Override public long getItemId(int position) {

return position; } @Override public View getView(int position, View convertView, ViewGroup parent) { ImageView thumbnail; TextView quote; if(convertView == null) { convertView = mInflator.inflate(R.layout.list_item_layout, parent, false); } thumbnail = (ImageView) convertView.findViewById(R.list.thumb); thumbnail.setImageResource(mDataSource.getmPhotoPool().get(position)); quote = (TextView) convertView.findViewById(R.list.text); quote.setText(mDataSource.getmQuotePool().get(position)); return convertView; }

The main function here is the getView function, since it is called for every item in the list view. It is responsible for binding the data source with the list view item. In it we first check if the convert view is null, the reason we do this is to check if the convertView returned is not a recycled view. The adapter does not create a new view for each and every item instead it creates a set number of views and reuses them as the users scrolls through the list. This is similar to how a UITableView reuses table view cells in iOS. Once this is done we get a reference to our image view and text view and fill it with data from our data source. The position variable returned is used as an index in the data source. Step 6: Getting things together We now have our adapter and data source set we just need to tell our list view to start using our adapter. Add the following private variable to QuoteReaderActivity:
private ListView mListView;

Then add the following lines in the onCreate method:

mListView = (ListView) findViewById(R.id.quotes_list); mListView.setAdapter(new QuoteAdapter(this));

Thats it! Now run the application, and you should see a screen like this:

Congrats! You have made a simple Android app that shows thumbnails of the famous Steve Jobs and his most famous quotes.

Constructing a Detail Page

Next we want to extend our app a bit so you can tap a quote to see it in full detail. It will show a large size picture and the quote written at the bottom. Step 1: Creating the UI Lets begin with creating the layout for this screen. Create a new xml file in the res/layout directory and name it quote_detail.xml. Add the following lines to the file:
<?xml version="1.0" encoding="utf-8"?> <ScrollView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" > <RelativeLayout android:layout_width="fill_parent" android:layout_height="fill_parent"> <ImageView android:id="@+detail/image" android:layout_alignParentTop="true" android:layout_width="fill_parent" android:layout_height="350dip"

android:layout_marginLeft="5dip" android:src="@drawable/steve_1" /> <TextView android:id="@+detail/quote" android:layout_width="fill_parent" android:layout_height="wrap_content" android:layout_below="@detail/image" android:textSize="24dip" /> </RelativeLayout> </ScrollView>

Here notice that the root view is a scroll view and it has only one child, which is a relative layout. This relative layout contains our image view for the picture and text view for the quote. The reason why a scroll view is used is since the quote could be long there is a possibility that it might go of the screen. A scroll view is smart enough to understand when its child view is bigger than the screen size and will automatically give you a scroll bar to scroll down. Step 2: Adding the Quote Detail activity Lets add the Quote detail activity this is responsible for presenting the quote_detail.xml layout to the user. First create a new class and name is QuoteDetail, make sure that it extends Activity. Override the onCreate function and set the content of the activity to quote_detail.xml. At this point QuoteDetail.java should look like the following:
public class QuoteDetail extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.quote_detail); } }

Step 3: Connecting two activities An activity in android is instantiated with an Intent, the details of an intent are not in the scope of this tutorial. But all you need to know is that an Intent is used to start an activity. In QuoteReaderActivity.java add the following at the end of your onCreate function.
mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() { @Override public void onItemClick(AdapterView arg0, View arg1, int position, long arg3) { Intent i = new Intent(QuoteReaderActivity.this, QuoteDetail.class); i.putExtra("position", position); startActivity(i); } });

What we are doing here is fairly straightforward. We are setting an item click listener and every time an item is clicked we create an Intent.

Notice that we pass the position variable to the intent, this is used to represent the position in the data source for the item clicked. Next add the following lines in QuoteDetail.java:
private private private private ImageView mImageView; TextView mQuote; int mPosition; DataSource mDataSource;

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.quote_detail); Intent i = getIntent(); mPosition = i.getIntExtra("position", 0); mDataSource = new DataSource(); mImageView = (ImageView) findViewById(R.detail.image); mQuote = (TextView) findViewById(R.detail.quote); mImageView.setImageResource(mDataSource.getmPhotoHdPool().get(mPosition)); mQuote.setText(getResources().getString(mDataSource.getmQuotePool().get(mPosition))); }

As you can see we retrieve the position sent by the QuoteReader activity from the intent and use that to fill in the image view and the text view. One last thing we need to do before you can run the application is to add an entry for this activity in your manifest. Lets not get into the details of the manifest but take it as a thumb rule to always add any new activity to the manifest. So add this line to the manifest (AndroidManifest.xml):
<activity android:name=".QuoteDetail" android:screenOrientation="portrait"> </activity>

Now its time to finally run the application. You should have a complete working app with both a master and detail view!

Uploading to the Android Market

Before I end the tutorial, I wanted to write down the steps to follow to upload an application to the android market. Here is a brief step-by-step guide:

First you need to get yourself a developer license by signing up here. Its costs an affordable $25 to get one. Next you need to obtain a suitable private key. This key will be used to sign your application. To do this use the keytool command, enter the following command in a terminal:

keytool -genkeypair -v -keystore YOUR_KEY_NAME.keystore -alias YOUR_ALIAS_NAME

-keyalg RSA -keysize 2048 -validity 10000

Running the example command as above, Keytool prompts you to provide passwords for the keystore and key, and to provide the Distinguished name fields for your key. It then generates the keystore as a file called YOUR_KEY_NAME.keystore. The keystore and the key are protected by passwords you entered.

Now you need to compile our application in release mode. In eclipse right click on the project and select Android Tools\Export Signed Application Package. Then specify the keystone and password information you set up previously.

Thats all; your APK is ready to upload to the android market!

More information on Android

Here are a few blogs that I think have real solid content:

Android developer blog Romain guys blog Daniel lews coding thoughts

Videos: Once you think that you have a basic grasp on android, the Google I/O videos are a great source. Books: I personally started off with Professional Android Application Development by Retro Meier and I strongly recommend it for any beginner. Another highly recommended option is the set of books by CommonsWare, such as this one.

Where to go from here

Here is the complete example project with all the code from the above tutorial. At this point, you should have a very basic understanding of how things work in the Android world. This should give you a good start to explore and create amazing apps. Youre ready to move on to the next part in this series on Android development, which will take you through some major improvements to the QuoteReader project. Along the way, youll learn more key Android concepts. If you have any questions, comments, or suggestions, please join in the forum discussion below! Note from Ray: If you enjoyed this tutorial and/or want more Android tutorials here in the future, please let us know in the comments for this post!

http://www.xtensivearts.com/topics/tutorials/page/2/ http://marakana.com/forums/android/general/ http://www.google.com/events/io/2010/sessions.html http://insanitydesign.com/wp/projects/nehe-android-ports/

Using the Android SDK tools with Windows 8 Consumer Preview

SMARTPHONES TABLETS NEWS FEATURED

By Jerry Hildenbrand | Mar 07 2012 | 4:24 pm | 31 COMMENTS

Unlike the Windows Phone SDK, the Android SDK works fairly well with the Windows 8 consumer preview. We know a lot of you folks want to be on the bleeding edge, and for Windows users that means installing the Win8 preview on your computer at home. I decided to dive in and see what was working, and what wasn't, and installed it on my laptop to test things out. The verdict -- most everything works just as it did before. It's just harder to get to it with Windows' sillynew interface. Hit the jump, and we'll have a look. I repartitioned, swore a bit, and ended up just wiping everything and installing a fresh copy of Win 8 on my laptop. I then installed the Samsung drivers, and the

Android SDK (release 16, available here), Sun Java, and rebooted. The good news is that everything from the SDK works, and Android devices are recognized with no extra software installation.

File transfers
When you plug your Android phone in, you're greeted by a new style pop-up box asking what you want to do when you plug this type of media in. If you ignore it, it goes away in a few seconds. But if you click it you're faced with a choice based on the programs you've got installed -- things like open pictures in Photo Viewer, play video with VLC, and so forth. You can also choose to open the folder to view all the files, and this is probably what you should pick. When you choose this, the new explorer opens in a new window, displaying the drive assigned to the newly mounted media. If you ignore the pop-up, you can open the drive through Explorer or My Computer.

Phones and tablets that use MTP instead of USB Mass Storage for file transfer work the same way. Plug the device in, let Windows configure it the first time, and you see the same pop-up dialog. You won't be asked to install any extra software, and things work just as you'd expect them too. It took 16 years, but it looks like Microsoft got it right this time, at least for removable media.

The Android SDK

The prerequisites to install and use the SDK are all the same -- the Sun Java JDK, enough free space, and a 32-bit backwards-compatible environment if using a 64-bit OS. Luckily, Windows 8 will install the JDK just fine and has the required 32-bit libraries on the 64-bit version to make SDK magic happen. Again, it's done just like it was on previous versions of Windows, and everything went without a hitch. Once installed, all your adb commands work as expected. You can still set your PATH variable in Win 8, it's juts a bit trickier to find. Open the Control Panel, click More Settings, then search for "Environmental Variables." When you find them, click "Edit the system environment variables." The rest is the same as before. Hiding things from the user seems to be a trend in the new Windows, and one that will tend to make more work for our advisers and Android hacking in general. Curse you Microsoft. But, as mentioned, adb works fine.

But Fastboot doesn't.

This throws a big wrench in the works if you've got a device that uses the fastboot protocol. This means all three Nexus devices, and several others. It also means access to the HTC bootloader unlocking toolisn't going to happen, at least not yet. This could be problematic. I say could, because it's quite possible that a small edit to the Android driver .ini file, or an updated set of drivers from an OEM, or a new version of the fastboot executable will make this a non-issue. I'm betting one of the three happens, but for now, doing things exactly the same way that works with Windows 7 does not work with Windows 8. Further investigation is needed, but for now, if you need fastboot, skip the Windows 8 preview. And don't worry. I'm uninstalling this monstrosity Windows 8 and trying the newest Ubuntu 12 beta to see how it all works. Look for that in a day or two. I love choices.

How to Learn Android Development/ Best books to learn android for beginners
Im writing this post out of my personal experiences when I first tried to learn android development.Android programming is with Java. Therefore programming for android will be

easier if you know java well. Eventhough programming language is Java, it runs on a custom Dalvik Virtual Machine than a JVM. Therefore knowing java will help you to headstart on syntax and common java libraries. If you are new to java, I recommend these titles to you as i found them very simple and effective to learn.

1. Head First Java from OReilly Media

Kathy Sierra and Bert Bates

2. Sams Teach yourself java in 21 days Rogers Cadenhead & Laura Lemay

3. Sams Teach Yourself Java in 24 Hours (5th Edition) Rogers Cadenhead

Once you get a base in the java language, then you can dive into the android programming world. Most professionals suggest the Official Android Developers Guide as the most simple way to learn. It includes a pretty simple introduction and many example applications explained. But if you are more comfortable in learning from a book than from developer documentation, then try these titles. This is a list of 5 android programming titles that I found simple and useful Click on the links to view the details of the book on Amazon

1. Head First Android Development Jonathan Simon

2. Beginning Android 3

Mark L Murphy

3. Hello Android Ed Brunette

4. Beginning Android Application Development Wei-Meng Lee

5. Android Programming Tutorials Mark Murphy

Hi Xirurg , I've tried a few different books so far. I wouldn't describe any of them as perfect or complete, so I needed more than one.

Hello Android This is worth considering as an introductory text, and is the one I started with. I had an early edition, and it's probably more complete now. Amazon Link: Hello, Android: Introducing Google's Mobile Development Platform Pragmatic Programmers: Amazon.co.uk: Ed Burnette: Books Android Wireless Application Development This is my current favourite. It might not be as introductory as Hello Android, but it covers more topics. It's aimed at people with some Java experience. Amazon Link: Android Wireless Application Development Developer's Library: Amazon.co.uk: Shane Conder, Lauren Darcey: Books Mark

http://developer.android.com/sdk/installing/installing-adt.html

How To Install and Run Android 4.1 Jelly Bean SDK on Windows PC?
June 29, 2012 By Priyanka Bhowmick

inShare4 Yesterday Google officially unveiled Android 4.1 Jelly Bean at I/O conference. Jelly Bean holds a buttery smooth UI along with a bundle of new features including triple buffering, redesigned home screen, offline voice typing, more 18+ languages support, improved camera, notifications, Android beam and more. Currently Jelly Bean is available through OTA update only on Google Nexus and Xoom and said to be arriving by mid July. Although, Google released Android SDK for developers through which theyll be able to

run Jelly Bean in PCs. Heres a step by step guide on how youll be able to install the Android SDK and run Jelly Bean on your Windows PC.

Download Android SDK from here and Install it on your PC. Open SDK Manager from the installed location and wait for the files to get fetched

Once the fetching is complete select the packages you want to install. I selected the Tools and Android 4.1 (API 16) packages. Click Install 8 packages.

Select Accept and Install.

Wait until the packages are downloaded and installed.

After everything is downloaded, now set up the Android Emulator to run Jelly Bean on your PC.

Go to Android SDK Tools folder and start AVD Manager. Click on New and Create a Virtual Device > Create AVD > Ok.

Now select the virtual device from the list > Click Start > Launch.

Youll see the following screen after the emulator starts up. The first time boot up will take a few minutes.

Enjoy Jelly Bean on your PC!

Thanks #TeamAndroid

Enter Your Mail Address

Bio Latest Posts

Priyanka Bhowmick
Blogger and Admin at CyberJunkeez

Priyanka Bhowmick is a tech blogger and a web addict. She loves networking with people who carries the same interest. Blogging is not only her job but an interest converted into passion.

TABLE OF CONTENTS (HIDE)

1. Introduction 2. How to Install Android SDK

yet another insignificant programming notes... | HOME

3. Write your First Android Program Using Eclipse ADT

3.1 Hello-world 3.2 Hello-world by Coding 3.3 Hello-world using XML Layout

4. Publishing Your App 5. Using Android Debug Bridge (ADB) 6. Next?

Android SDK

How to Install and Get Started

1. Introduction

Android is an Operating System for mobile devices developed by Google, which is built upon Linux kernel. Android competes with Apple's iOS (for iPhone/iPad), RIM's Blackberry, Microsoft's Windows Phone (previously called Windows Mobile), Sambian OS, and many other proprietary mobile OSes.

Android Platform
Android is based on Linux with a set of native core C/C++ libraries. Android applications are written in Java. However, they run on Android's own Java Virtual Machine, called Dalvik Virtual Machine (DVM), which is optimized to operate on the mobile devices. The mother site for Android is www.android.com. For developers, visit http://developer.android.com to download the SDK, Android Training, API Gudies and API documentation.

2. How to Install Android SDK

NOTE: Installing all the necessary software needed for Android programming takes times It could take hours?!

Pre-Installation Check List

Before installing Android SDK, you need to install: 1. Java Development Kit (JDK): Read "How to install JDK". 2. Eclipse: Read "How to install Eclipse".

Now, you are ready to install the Android SDK.

Step 0: Read the "Android Training"

Start from Android's mother site @ http://www.android.com. Goto "Developers" @ http://developer.android.com. There are three main menus: Design, Develop, and Distribute. Start with "Develop", you can find the "Android Training", "API Guides", "Reference" and "Tools". For beginners, browse through the "Android Training".

Step 1: Download the Android SDK

Download the Android SDK from http://developer.android.com/sdk/index.html. For novices, choose the installer version by clicking the button "Download the SDK for Windows" (installer_r20-windows.exe). For Lunix and Mac, select "Other Platforms". For advanced programmers, I recommend that you choose the ZIP version (under the "Other Platforms") (android-sdk_r20-windows.zip). I prefer the ZIP version, as you could install many versions, rename the directory, and remove the installation easily. Read "Installing the SDK".

Step 2: Install Android SDK

Run the downloaded installer into a directory of your choice, e.g., "d:\bin\android-sdk"; or unizp the downloaded ZIP file. Take note of the installed directory. Hereafter, I shall denote the android installed directory as <ANDROID_SDK_HOME>.

Step 3: Install Android Platforms and Add -ons via "SDK Manager"
The Android SDK comprises 2 parts: the "tools" and the "Platforms & Add-ons". After running the installer (in the pervious step), the basic "tools" are installed, which are executables that support app development. The "Platforms & Add-ons" consist of ALL Android platforms (from Android 1.x to 4.x) and various Google Add-ons (such as Google Map API), which could be selectively installed. Now, we have to choose our Android "Platforms & Add-ons". 1. Launch Android's "SDK Manager", which is responsible for managing the software components. If you have run the installer, it should have started the SDK Manager after the installation. Otherwise, launch the SDK manager by running (double-clicking) "SDK Manager.exe" under the Android installed directory. 2. In "Add Platforms and Packages", select your target Android platforms and add-ons packages. For novices, select "Android SDK Platform-Tools", and at least one Android platform (e.g., Android 4.1 (API 16)) "Install".

Step 4: Install Eclipse Android Development Tool (ADT) Plug in

I suppose that you have installed Eclipse. 1. Launch Eclipse. 2. Install Eclipse ADT: From Eclipse's "Help" menu "Install New Software..." In "Work with", enter https://dl-ssl.google.com/android/eclipse/ Check ALL boxes Next Finish Restart Eclipse to use ADT plugin. 3. Configure Eclipse ADT: From Eclipse's "Window" menu Preferences Android In "SDK Location", select the Android SDK installed directory (e.g., "d:\bin\android-sdk").

Step 5: Create a Android Virtual Device (AVD) (or Emulator) via "AVD Manager"
AVDs are emulators that allow you to test your application without the real devices. You can create AVDs for different android platforms (from Android 1.x to Android 4.x) and configurations (e.g., screen size, orientation, SD card and its capacity). 1. From Eclipse's "Window" menu Preferences Android In "SDK Location", enter your Android SDK installed directory (e.g., "d:\bin\android-sdk"). 2. From "Window" menu AVD Manager. (You could also start the AVD manager by running "AVD Manager.exe" under the Android SDK installed directory.) 3. In "Android Virtual Device Manager" dialog "New". 4. The "Create New Android Virtual Device (AVD)" dialog appears. In "Name", enter "Android41_Phone". Select the "Target" Android platform, "SD Card Size" (e.g., 10MB, do not set a huge SD Card size, which would take hours to create.) Skin (screen resolution, e.g., WVGA800x480 for smart phone - Wiki "Graphics display resolution" for the various resolution) "Create AVD". You can test your AVD by launching the emulator. Start the AVD manager Select a AVD Click the "Start" button Check "Scale display to real size" to get a smaller screen that could fit in your display Launch. Wait patiently! The emulator is very slow and take a few MINUTES to launch. You can change the orientation (between portrait and landscape) of the the emulator via "Ctrl-F11". We typically create different AVDs to emulate different real devices, e.g., Android41_tablet of resolution (1024x768 XGA).

Step 6: Setup PATH

You can skip this step now if you are not familiar with PATH, but it is needed later. Include the android's tools directory (<ANDROID_SDK_HOME>\tools) and platformtools directory (<ANDROID_SDK_HOME>\platform-tools) to your PATH environment variable.

For Windows: Start "Control Panel" "System" (Vista/7) "Advanced system settings" Switch to "Advanced" tab "Environment variables" Choose "System Variables" for all users (or "User Variables" for this login user only) Select variable "PATH" Choose "Edit" for modifying an existing variable (e.g., In variable "Value", APPEND your <ANDROID_SDK_HOME>\tools directory "d:\bin\android-

sdk\tools"), followed by a semi-colon';', IN FRONT of all the existing path entries. DO NOT

remove any existing entry; otherwise, some programs may not run. Add the platform-tools directory to the PATH too.

3. Write your First Android Program Using Eclipse ADT

Android apps are written in Java, and use XML extensively. I shall assume that you have basic knowledge of Java programming and XML.

3.1 Hello-world
Step 0: Read
Go to "Android Training" @ http://developer.android.com/training/index.html, Read "Get Started", "Build your first app".

Step 1: Create a new Android Project

1. Launch Eclipse. 2. From "File" menu New Project.. Android Application Project Next. 3. The "New Android Project" dialog appears: a. In "Application Name", enter "Hello Android" (this is the Android appliation name that shows up on the real device). b. In "Project Name", enter "HelloAndroid" (this is the Eclipse's project name). c. In "Package Name", enter "com.example.helloandroid". d. In "Build SDK", select the latest version (e.g., Android 4.1 (API 16)). e. In "Minimum Required SDK", select "API 8 Android 2.2 (Froyo)" - almost all of the Android devices meet this minimum requirement Next. 4. The "Configure Launcher Icon" dialog appears, which allows you to set the application's icon to be displayed on the devices Next. 5. The "Create Activitiy" dialog appears. Check "Create Activity" Box Select "BlankActivity" Next. 6. The "New Blank Activity" dialog appears. . In "Activity Name", enter "HelloActivity". a. In "Layout Name", enter "activity_hello" (default). b. In "Title", enter "Hello" (this title will appear as the screen title) Finish. Eclipse ADT creates a default Hello-world Android app.

Step 2: Run the Android App

Run the application by right-click on the project node "Run As" "Android Application".

Be patient! It takes a few MINUTES to fire up the emulator! Watch the Eclipse's status bar for the launching progress; and the console view (or LogCat view) for messages. Once the emulator started, unlock the device by holding and sweeping the "lock" to the right (or left). It shall launch your Hello-world app, and displays "Hello, world!" on the screen with a title "Hello". If your program is not launched automatically, try launching it from the "app menu" manually, after the emulator is started. Look for the icon "Hello".

Trying launching the app from "HOME" "..." Look for the icon "Hello". Also try "HOME" "..." "MENU" "Manage Apps" Select "HelloAndroid" Uninstall.

NOTE: DO NOT CLOSE the emulator, as it really takes a long time to start. You could always
re-run or run new applications on the same emulator.

Run the Android App on Real Devices

To run the Andriod app on the real devices: 1. Connect the real device to your computer. Make sure that you have the "USB Driver" for your device installed on your computer. You can find the "Google USB Driver" @ http://developer.android.com/sdk/win-usb.html, and Google's certified "OEM USB Drivers" @http://developer.android.com/tools/extras/oem-usb.html. If you device is not certified there, good luck! It took me many hours to find a compatible driver for my cheap Pad. 2. Enable "USB Debugging" mode on your real device: from "Settings" "Applications" "Development" Check "USB Debugging". This allows Android SDK to transfer data between your computer and your device. Also enable "Unknown source" from "Applications". This allows applications from unknown sources to be installed on the device. 3. You shall see the message "USB Debugging Connected" when you plugs the USB cable into your computer.

4. From Eclipse, right-click on the project node Run As Android Application. 5. The "Android Device Chooser" dialog appears. Select your real device (instead of the AVD emulator) OK. 6. Eclipse ADT installs the app on the connected device and starts it. You can also use the "adb" (Android Debug Bridge) tool (under "<ANDROID_SDK_HOME>\platform-tools") to install the ".apk" file ("HelloAndroid.apk") onto the real devices:
// Change directory to <project-root>\bin, where the ".apk" is located // -d option for real device > adb -d install filename.apk 2402 KB/s (157468 bytes in 0.064s) pkg: /data/local/tmp/filename.apk Success > adb --help

3.2 Hello-world by Coding

Let's continue from the previous example. Expand the "src" node. Expand the "com.example.helloandroid" package node. Open the "HelloActivity.java", and replace it with the following codes:
1package com.example.helloandroid; 2 3import android.app.Activity; 4import android.os.Bundle; 5import android.widget.TextView; 6 7public class HelloActivity extends Activity { 8 /** Called when the activity is first created. */ 9 @Override 10 public void onCreate(Bundle savedInstanceState) { 11 super.onCreate(savedInstanceState); 12 TextView textView = new TextView(this); // Construct a TextView UI component 13 textView.setText("Hello, from my code!"); // Set the text message for TextView 14 setContentView(textView); // this Activity sets its content to the TextView 15 } 16}

Run the application by right-clicking the project node "Run As" "Android Application". You shall see the message "Hello, from my code!".

Dissecting the " HelloActivity.java " - Application, Activity & View

An application could have one or more Activity. An Activity, which usually has a screen, is a single, focused thing that the user can interact with the applicatoin. The HelloActivity extends theandroid.app.Activity class, and overrides the onCreate() method. The onCreate() is a call-back method, which will be called by the Android system when the activity is launched. A View is a UI component (or widget, or control). We construct a TextView (which is a subclass of android.view.View), and set its text message. We then set the content-view of the HelloActivity screen to this TextView.

Android Application Structure

The Android project (under Eclipse ADT) consists of several folders:
src: Java Source codes. The Java classes must be kept in a proper package with at least

two levels of identifiers (e.g., com.example).

res: Resources, including drawable (e.g., images and icons), layout (UI components and

layout), values (e.g., locale strings for internationalization).

asset: where you store raw files (e.g., configuration, audio and image files). gen: Generated Java codes. bin: Compiled bytecodes (in sub-directory classes), and the ".apk" (Android Package

Archive file).
AndroidManifest.xml: The manifest to describe this app, such as its activities and

services.
default.properties: holds various settings for the build system, updated by the ADT. Android 4.1: the build target platform, with link to Android API ("android.jar").

Android Application Descriptor File - " AndroidManifest.xml "

Each Android application has a manifest file named AndroidManifest.xml in the project's root directory. It descibes the application. For example, our "HelloAndroid" application, with an activity HelloActivity, has the following manifest (generated automatically by the Eclipse ADT):
1<manifest xmlns:android="http://schemas.android.com/apk/res/android" 2 package="com.example.helloandroid" 3 android:versionCode="1" 4 android:versionName="1.0" > 5 6 <uses-sdk 7 android:minSdkVersion="8" 8 android:targetSdkVersion="15" /> 9

10 <application 11 android:icon="@drawable/ic_launcher" 12 android:label="@string/app_name" 13 android:theme="@style/AppTheme" > 14 <activity 15 android:name=".HelloActivity" 16 android:label="@string/title_activity_hello" > 17 <intent-filter> 18 <action android:name="android.intent.action.MAIN" /> 19 <category android:name="android.intent.category.LAUNCHER" /> 20 </intent-filter> 21 </activity> 22 </application> 23 24</manifest>

The <manifest> element specifies the package name, version-code and version-name. The version-code is an integer uses by the Android Market to keep track of new version, usually starts at 1. The version-name is a string for your own identification. It is interesting and confusing that two elements are used to identify a version, e.g., Android platform 4.1 has API Level 16.

The <manifest> contains one <application> element. The <application> element specifies the icon, label (the application's title) and theme of this application. It contains one ore more <activity>elements. This application has one activity named HelloAndroid. The <activity> element declares its program name (".HelloActivity" where '.' is relative to the package com.example.helloandroid, you can also use fully-qualified name); and label (the activity's screen title). It may contain<intent-filter>.

The <intent-filter> declares

that

this

activity

is

the

entry

point

(android.intent.action.MAIN) of the application. This activity is to be added to the application launcher (android.intent.category.LAUNCHER).

3.3 Hello-world using XML Layout

Instead of writing program codes to create the UI. It is more flexible and recommended to layout your UI components via a descriptive XML layout file. In this way, you don't need to hardcode the views, and you can easily modify the look and feel of the application by editing the XML markups. The programming codes can therefore focus on the business logic. (This is similar to the Model-View-Control (MVC) framework used in web applications where the views are written in JSPs using markups and the controls in Servlets, which are clearly separated. This is also similar to client-side programming where HTML is used for

contents, CSS for presentation and JavaScript for programming logic. Again, views, contents and programs are clearly separated). To improve the performance, the XML files are compiled into binary using the Android Asset Packaging Tool (aapt). The devices store them as binary, and the file is read in binary, instead of converting back to XML. Let's rewrite our hello-world to use XML layout.

Step 1: Create a New Android Application

Create a new Android project called "HelloAndroidXML". Use "HelloAndroidXML" for the application name and project name, "com.example.helloandroidxml" for package name. Create a "BlankActivity" called "HelloActivity", with layout name "activity_hello" and title "HelloXML".

Step 2: Define the Layout in XML - " res\layout\activity_hello.xml "

Expand the "HelloAndroidXML" project node. Expand the "res" node and "layout" node. Open the "activity_hello.xml". Eclipse provides different views for a XML file: Graphics Layout and XML. Select the "activity_hello.xml" tab (at the bottom of the panel) and study the code:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" >

<TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" android:padding="@dimen/padding_medium" android:text="@string/hello_world" tools:context=".HelloActivity" /> </RelativeLayout>

The activity_hello.xml file declares a TextView that holds a text string. Instead of hardcoding the string content, a string reference called@string/hello_world is used, with the

actual string coded in res/values/strings.xml. This approach is particular useful to support internationalization, as you can customize different strings for different locales. This activity's uses a "relative layout", where its components are arranged relative to each other. It has width and height matching its parent ("match_parent"). The screen contains a TextView component, with its text obtained from the string reference "@string/hello_world". The TextView component has width and height big enough to hold its content ("wrap_content"), and is centralized horizontally and vertically.

Step

3:

Defining

String

References

and

Values

" res\values\string.xml "

Expand res/values node. Open strings.xml, and study the code:
<resources> <string name="app_name">HelloAndroidXml</string> <string name="hello_world">Hello world!</string> <string name="menu_settings">Settings</string> <string name="title_activity_main">HelloXML</string> </resources>

This "string.xml" defines these string references and values:

The string reference "hello_world" contains string value of "Hello world!". Change it to "Hello, from XML!". The string reference "app_name" contains the application's name, that you entered when you created the project. This reference is used in "AndroidManifest.xml". The string reference "title_activity_main" contains the activity's title. This reference is also used in "AndroidManifest.xml". Change it to "Hello in XML Layout"

Step 4: The Activity - " HelloActivity.java "

Next, study the "HelloActitivy.java" (right-click on the project Expand "src" node Expand package node "com.example.helloandriodxml"), as follows:
package com.example.helloandroidxml;

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

public class HelloActivity extends Activity {

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_hello); } @Override public boolean onCreateOptionsMenu(Menu menu) { getMenuInflater().inflate(R.menu.activity_hello, menu); return true; } }

The "HelloActivity" sets its content-view to "R.layout.activity_hello", which is mapped to the XML layout file "res\layout\activity_hello.xml" that we have studied earlier.

Step 5: Run the App

Run the application (select "Run As" menu "Android Application"). You shall see the new string "Hello, from XML!" and new title "Hello in XML Layout" displayed on the emulator.

Step 6: The Generated Resource Reference Class - " gen\R.java"

The Eclipse ADT automatically generates a "R.java", which keeps track of all the application resources, in "gen" directory as follows:
package com.example.helloandroidxml;

public final class R { public static final class attr { } public static final class dimen { public static final int padding_large=0x7f040002; public static final int padding_medium=0x7f040001; public static final int padding_small=0x7f040000; } public static final class drawable { public static final int ic_action_search=0x7f020000; public static final int ic_launcher=0x7f020001; }

public static final class id { public static final int menu_settings=0x7f080000; } public static final class layout { public static final int activity_hello=0x7f030000; } public static final class menu { public static final int activity_hello=0x7f070000; } public static final class string { public static final int app_name=0x7f050000; public static final int hello_world=0x7f050001; public static final int menu_settings=0x7f050002; public static final int title_activity_hello=0x7f050003; } public static final class style { public static final int AppTheme=0x7f060000; } }

The R.java ("R" stands for resources) indexes all the resources used in this application in the static nested classes such as layout and string. For example, the inner class layout's property activity_hello (R.layout.activity_hello) references res\layout\activity_hello.xml; class string references res\values\strings.xml. the inner

4. Publishing Your App

To publish your apps on Android Maket/Google Play, you need to sign your app with your digital certificate. (During development, you app is signed using a debug certificate by the Eclipse ADT.)

Signing Android Apps

1. From Eclipse, right-click on the project Export... Android Export Android Application. 2. In "Project Checks" dialog Next. 3. In "Keystore selection" Create new keystore In "Location", enter the filename for the keystore (e.g., keystore.db) Set your password for the keystore. 4. In "Key creation", enter the data Finish. References:

1. Signing

Your Applications

@ http://developer.android.com/tools/publishing/app-

signing.html. 2. For keystore management, read JDK documentation on "keytool - Key and Certificate Management Tool".

5. Using Android Debug Bridge (ADB)

ADB lets you manage the connected real devices and emulator AVDs. ADB actually consists of three parts:

A client program called "adb.exe" (kept under the "<ANDROID_SDK_HOME>\platformtools").

A server that that runs on your development machine, which is responsible for communicating between an "adb" client program and the connected real devices or emulator AVDs.

The ADB daemon, which runs as a background process on every real device and emulator AVD. The ADB server connects to this daemon for communication.

You can use the "adb" client to install Android apps (in ".apk" format), or copy files between your development machine and real device's internal storage and external SD card. From a CMD shell, launch the "adb" client program (you need to include the "<ANDROID_SDK_HOME>\platform-tools" in PATH environment variable):
// List the command options > adb --help ...... // List all the devices connected, take note of the device serial number > adb devices ...... // Install app in the device of the given serial number > adb s device_id install app_filename.apk // Install app on real device > adb -d install app_filename.apk // Install app on emulator > adb -e install app_filename.apk // Copy the file from the development machine to the device > adb push computer_filename sdcard_filename // Copy the file from the device to development machine > adb pull sdcard_filename computer_filename

6. Next?
Continue with the "Android Training" @ http://developer.android.com/training/index.html. Read the Android "API Guides" @ http://developer.android.com/guide/components/index.html. Study the Android sample codes (in Android SDK "samples" directory), especially the "API Demos". To run the sample programs in Eclipse: Select "File" menu "New" "Project..." "Android" "Android Sample Project" E.g., "API Demos". To import an existing project: 1. Select "File" menu "New" "Project..." "Android" "Android Project from Existing Code" Next. 2. In "Import Project" dialog, browse and select the desired project from the Android SDK's "samples" (e.g., "ApiDemos"). Check "Copy projects into workspace". 3. Run the application. Right-click on the project "Run As" "Android Application".

REFERENCES & RESOURCES

1. Android SDK @ http://developer.android.com/sdk/index.html. 2. "Android Training" @ http://developer.android.com/training/index.html. 3. Android "API Guides" @ http://developer.android.com/guide/components/index.html.

Link to Android's References and Resources

Latest version tested: Android 4.1, Android SDK r20, Eclipse 4.2 (Juno) Last modified: July, 2012 Feedback, comments, corrections, and errata can be sent to Chua Hock-Chuan (ehchua@ntu.edu.sg) | HOME

Sign Up or Log In or Log In via

Follow us on Pinterest HomeArticlesCommunityMy Profile

Search

Edit

Home

Categories

Computers and Electronics Phones and Gadgets Smartphones Android

How to Set up an Android Development Environment

8 authors | 26 revisions | Last updated: December 10, 2012
Article

EditDiscuss

The Android mobile operating system has seen a tremendous increase in adoption by mobile phone manufactures. This has had the effect of creating a large user base of Android followers. Naturally, with the increase in the popularity of Android devices, the desire for quality application intensifies. Android is based on the Java development language and any beginner-level Java developer can jump right in and start developing applications. The purpose of this guide is to outline in detail the steps necessary to set up the initial development environment for creating Android applications. The guide will address the installation of the Android Software Development Kit (SDK) and the initial set-up necessary for allowing Android OS emulation. The intended audience for this guide is beginner-level developers with basic knowledge of Integrated Development Environments (IDE). With a little dedication and hard work, you can start making Android applications very soon.

EditSteps
Initial steps

1. 1
Download an IDE.

Ads by Google PG Diploma in Event Mgmt

INLEAD offers Assured placement Avg Salary 4 to 6 lacs @ Top MNCs www.inlead.in

For the purpose of this example, will be using Eclipse. You can download the latest version of the software here:http://www.eclipse.org/downloads/packages/release/indigo/r. You must choose the version that corresponds to your OS of choice.

2. 2
Install Eclipse.

Make sure to take note of the installation directory and workspace for later reference.

3. 3
Download and install the Java Runtime Environment (JRE).

You can find the download file here:http://www.oracle.com/technetwork/java/javase/downloads/jre-6u25-download346243.html.

You can find the download file here:http://www.

4. 4
Download and install the Java Development Kit.
o

you can find the download file here:http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u3-download1501626.html. Android SDK

1. 1
Install the Android SDK

The SDK starter package includes the Android SDK and AVD Manager. This is a tool that we will now use to download some required SDK components into our development environment.

The SDK starter package includes the Android SDK and AVD Manager.
o

The starter package we downloaded only contains the newest version of the SDK tools. In order to develop Android applications, we will need to download at least one Android platform so we can emulate a phone/tablet via our computer hardware. In the root of the SDK directory, find and execute the SDK Manager.exe file. Note: Right-click and run as administrator to avoid any permission declination.

In the root of the SDK directory, find and execute the SDK Manager.
o

Choose the Android platform version which you wish to develop on and click Install packages. You will be prompted with a pop-up, check off Accept and click Install.

Choose the Android platform version which you wish to develop on and click Install packages.

2. 2
Download and Install the Android Development Tools (ADT) plugin for Eclipse

o o

Google provides a custom plugin for Eclipse, called ADT, that aids developers in creating Android applications faster and more efficiently. Open Eclipse and select Help-->Install New Software

Open Eclipse and select Help-->Install New Software.

o o

Click Add In the pop-up dialog, type 'ADT Plugin' in the Name field and enter the following URL in the location field: https://dlssl.google.com/android/eclipse/

In the pop-up dialog, type 'ADT Plugin' in the Name field and enter the following URL in the location field: https://dlssl.
o o

Click OK. If you're having issues in downloading the plugin, use "http" instead of "https". Select the 'Developer Tools' option and click Next. Once the tools are downloaded, click Next.

Select the 'Developer Tools' option and click Next.

o

Read and accept the License Agreements. When you are done, click Finish and restart Eclipse. Note: you may encounter a Security Warning message notifying you of unsigned content. If you do, click OK.

3. 3
Configure ADT plugin

o o

In Eclipse, select Window --> Preferences . Select Android from the panel on the left. Choose if you want to opt into sending usage statistics and click Proceed.

Select Android from the panel on the left.

o o

In the SDK Location field, click Browse and choose the directory where you saved the Android SDK in step Click Apply -->OK. You have now configured the ADT plugin successfully.

4. 4
Configure an AVD

Next , set up an AVD so that you can emulate a phone/tablet using your computer hardware. This will allow you to test the application being developed without requiring a physical Android device. In Eclipse, navigate to Window --> AVD Manager. Click New to fill in the details of the virtual device.

In Eclipse, navigate to Window --> AVD Manager.

Choose a name that conforms to the naming rules specified at the bottom of the window.

The Target field specifies the version of Android you wish to have the virtual device running on. Notice that the list of the drop down menu only contains version of the Android OS that you selected to download during the SDK installation step. If you want the AVD to run another version of the OS, you must download appropriate version packages in the SDK Manager. The rest of the options relate to the specific features that you wish to customise the AVD with. These features represent hardware features present on physical Android devices. For instance, you may customise the screen resolution of the emulated device, availability of GPS. You can even specify a custom battery level state to test particular usage scenarios that app-users may encounter. Once you are satisfied with the configuration of the AVD, click Create AVD

5. 5
Congratulations, you have now completed the setup of the Android development environment. You are ready to begin coding your very first Android application. There is an abundance of tutorials on the web regarding the creation of a simple app. Outlined below are some handy links for your consideration.
o o o

Project setup and Hello World tutorial:http://developer.android.com/resources/tutorials/helloworld.html Introductory information on developing for the Android OS:http://developer.android.com/guide/developing/index.html Testing applications using physical devices:http://developer.android.com/guide/developing/device.html

Ads by Google Free e-Learning Modules

Intuitive Agilent VEE Programming Basics Modules. Get them Now! www.agilent.com/find/learnvee

Cognizant Hiring Jan 2013

562+ Openings. Exp: 0 to 8 Yrs. Apply Now & get Multiple Interviews TimesJobs.com/Cognizant-Jobs-Urgent

Travel Abroad Hassle Free

Get Amex Prepaid Travel Cards. Use at millions of locations worldwide. AmericanExpress.com/Enquire-Now

EditTips When installing any software mentioned in this guide, always make sure to install the version that is compatible with your OS version (32/64 Bit). Failure to do so may cause compatibility errors later on. When installing the SDK, choose the standalone installer .exe file for an easier time during installation. If the installation of SDK components fails, run the SDK manager under 'Administrator Permission'

Ads by Google

Enterprise Android Device

Manage Enterprise Android Devices. Start Your Free Trial Today! Air-Watch.com

Xtab A9 Plus with IPS

7" IPS HD, 5 point touch, 1.2GHz A9 1GB RAM,8GB Memory,Android 4.0,HDMI www.nxgelectronics.in

TCS Fresher Jobs

Top Companies Are Hiring Now Submit CV to Apply & Find Jobs! www.monsterindia.com

EditThings You'll Need PC/ Laptop running a version of Microsoft Windows Operating System ( For purpose of this guide) An active Internet connection 500+ MB of hard-drive space (for installations) More detailed requirements are found here:http://developer.android.com/sdk/requirements.html

EditSources and Citations http://www.oracle.com/technetwork/java/javase/downloads/jre-6u25-download-346243.html http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u3-download-1501626.html http://developer.android.com/guide/developing/devices/index.html http://developer.android.com/sdk/installing.html http://www.java.com/en/download/faq/whatis_java.xml Nourie, Dana (24 March 2005). "Getting Started with an Integrated Development Environment". Sun Microsystems, Inc.. Retrieved 19 March 2012.

Article Info
Categories: Android
Share this Article:

Discuss Print Email Edit

Send fan mail to authors Ads by Google Quad-Core ARM Computer Dual Displ 3D-Graphic&Video 1GB RAM 2GB FLASH, from 89 - 125$ www.toradex.com/embedded-modules

Grab Free Eyeglasses Use Code "FreeFrame" to claim your Free Eyeglasses worth Rs.999. Hurry www.lenskart.com/eyeglasses

Thanks to all authors for creating a page that has been read 861 times. Was this article accurate?
Yes No

Write An ArticleRandom Article

Related Articles

Create QR Codes with an Android Phone

Save Battery Power on an Android

Install

the wikiHow Android App

Adjust the Screen Timeout on an Android Phone

Ads by Google

Android Software Android Applications Android App Android Google Install Android SDK

Hide all ads - Why?

Featured Articles

Divorce Your Credit Card

Keep a Life Changing Resolution

Tightline Eyes

Lose Weight

Meet a Community Member

Meet Lewis, a member of our community for over 5 years who's written and rewritten over 50 wikiHow articles with a penchant for detail and accuracy. His goal is to write pages that end up being the best articles on the subject available anywhere. His favorite article is How to Make Milk Steak With Jelly Beans, which he and Caidoz saved from deletion with the help of Dave,

who sponsored the steak. The article went from being nominated for deletion to being featured. Collaboration at its best! Join The Community
- collapseThings

to Do

Write an Article Edit this Article Request a New Article Answer a Request Login for more!
+ expandPlaces

to Visit Follow Us On...

the how to manual that you can edit Home

About wikiHow Terms of Use RSS Site map

Search

Explore Categories

Arts and Entertainment Cars and Other Vehicles Computers and Electronics Education and Communications Family Life Finance and Business Food and Entertaining Health Hobbies and Crafts Holidays and Traditions Home and Garden Other Personal Care and Style Pets and Animals

Philosophy and Religion Relationships Sports and Fitness Travel wikiHow Work World Youth
All text shared under aCreative Commons License. Powered by Mediawiki.

Thank Our Volunteer Authors.

Give this article a +1.

the Android SDK

Send to a friend Print

Not signed in

Anony

tember 2011, 11:18 AM Login here

K provides the tools needed to create mobile applications. It also ships with a full-featured emulator create and run Android on a computer.

the Android SDK

Sign up now!

ed the Android SDK, you can play with various releases of Android including the Honeycomb release (3.1) s.

o developer.android.com and click on the SDK link or the Download link. Select the installer for your platform. ller is highlighted in the image. If you are running OSX or Linux, follow the instructions here.

RSS feeds

Most viewed h

1.

How to d

and Linux

the step-

screensh

2. 3.

How to d first)

and Wind

How to d

Windows

first) -- th

with scre

4.

How to d

Linux (Vi

step-by-s

screensh

5.

How to d

(with Vist

step-by-s

screensh

Android Installer

6. 7.

Building a

How to d

Linux (wi

- the step

screensh

Most viewed a run for the first time, will scan to find the JDK (see Figure 10). If the installer complains that it cannot find the Most commen ou have installed it, then press the back button and click Next, this should resolve the problem. The installer etimes it does not find the JDK properly. Make a note of the directory/folder where you install the Android tools, ter to configure the Eclipse IDE plug-in.

Tags

3 (41) 3D (24) 3G (176) 4G (11) 802.11n (17) ABC (15) ACCC (16) Acer (95) adobe (20) Adobe Flash (10) ADSL (30) ADSL2+ (33) advertising (19) AFACT (17) Alienware (12) all in one (14) all rounder (18) All-in-One (17) amazon (31) AMD (83) Android (345) App Store (43) app stores (23)

Accessories (135)

installer detects the JDK if it is installed. nstaller has copied all of the tool files into the target directory, it will start the SDK Manager automatically. The nloads the Android OS platforms and gives you the option to select different releases to download. So, you can

Android Market (1

Apple (738) d just a specific set of releases for instance 2.2 and 2.3, or you can download all of the releases. In this step, Apple iPad (40) bottom right) it will download all releases.
Apple Store (22) Apple TV (11) Applications (22) Apps (183) ARM (21) asus (136) ATI (35) Atom (154)

Apple iPhone (19)

Australia (183) aviation (11) Backup (20) bargain (14) Bargains (53) Battery life (12) Best Apps (75)

Barack Obama (1

Best Apps Androi

Best Apps BlackB

Best Apps iOS (19

Best Apps iPhone beta (42) BigPond (26) BitTorrent (46) BlackBerry (152) Blackberry Curve Blackberry Curve

Best Apps Window

Blackberry Bold (3

Blackberry Pearl ( Blackberry Storm Bluescreen (18) Bluetooth (15) BluRay (10) Blu-ray (43) Broadband (203)

BlackBerry PlayB

browsers (48) Bugs (24) option is to download everything, but this will download around 1GB of platform files. If you prefer to reduce the business (22) business noteboo n select the following options: buyers guide (13) Cable (18) Platform-tools Canon (17) n of Android SDK Canonical (15) Android 2.3.3, API 10 cases (16) Android 2.2, API 8 Censorship (76) Android 2.1, API 7 Centrino (21) DK API 10 Centrino 2 (17) DK API 8
CES (50) CES 2009 (11)

nager set to download all platform releases of Android.

DK API 7

y Google Inc., Android API10

y Google Inc., Android API8

y Google Inc., Android API7

Driver package

atibility package

CES 2010 (29) chips (48) Chrome (42) Chrome OS (17) Cleanfeed (59) cloud (20) cloud apps (13) Cloud computing Competition (10) Computer (16) Computex (14) connectors (13) copy (12) Copyright (17) Core (23) Core 2 (13) Core 2 Duo (37) core 2010 (13) Core i3 (21) Core i5 (47) Core i7 (55) Corsair (11) CPU (24) CPUs (66) Defects (14) Dell (151) design (22) desktop (31) desktops (38) Developers (58)

Components (164

desktop replacem

digital camera (13 Digital TV (11) discount (14) Discounts (20) display (15) displays (35) downloads (22) DRM (19) DSLR (16)

digital cameras (1

ress window will show the approximate time to complete the download and indicate the various platforms that aded and installed. These are stored in the platforms sub-directory (in the location where you originally place

nager selections set to download only a sub-set of the platforms.

dual boot (12) dual-core (11) DVD (24) eBay (27) e-book (11)

e-book reader (10 ebooks (25) Education (14) Eee (20) Eee PC (48) email (29) Excel (19) FaceBook (49) fibre (36) filtering (39) finance (22) firefox (49) flash (31) flash drives (15) Foxtel (10) Free (24) Freeware (24) Froyo (12) Fujitsu (24) funny (49) Gadgets (127) Gamers (21) Games (87) Gaming (153) gaming keyboard gaming PC (33) gaming pcs (10) geekgear (16) Gigabyte (33) glitches (26)

ebook readers (13

Environmentally fr

Fibre to the home

flash memory (12

Free software (25

gress bar shows information of the various packages as they are installed. have downloaded the various platform tools, we need to create a virtual Android device using the SDK Manager emulator.

gaming accessori

Gaming Notebook

ollows - Select Virtual devices from the list on the left hand side of the window (see Figure 14). Select New

ual device. We will create a virtual device for the Android 2.2 platform (see Figure 15). Provide a value for the Gmail (19) ber of sample applications expect this and will not run properly otherwise. A value of around 256MB is sufficient google (300) he larger this value, the larger the image of the virtual machine on your computer. Finally, enable the Snapshot Google Apps (22) llow you to restart a virtual machine quickly. Google Chrome (1

Google Docs (13)

Google Maps (19) GPS (45) GPU (22) GPUs (30) graphics (16)

Government (143

graphics card (13

graphics cards (31 green (11) GUIs (12) hack (11) hackers (17) Hacking (11) hard drive (10) Hard drives (60) hardware (19) HD (19) HD Sex (10) HDD (12) HDMI (13) HDTV (22) home networking

graphics chips (12

Hardware - Backe

K Manager with no virtual devices configured.

High definition (16

Home Server (16) Honeycomb (13) How To (346) HP (122) HSDPA (90) HSPA (17) HTC (87) HTC Dream (21) HTC Magic (14) HTPC (22)

home servers (10

How to rip anythin

Huawei (15) iCloud (10) IDF (30) iiNet (48) iMac (30) inflight (11) Inspiron (11) Install (18) Intel (451) Intel Atom (72) Intel Core (14) Internet (721)

Ice Cream Sandw

inflight internet (13

internet censorshi

Internet Explorer (

Internet Explorer 8 Internode (32) Interview (14) iOS (102) iPad (197) iPad 2 (18) iPhone (387) IPhone 3G (85) iPhone 3GS (49) iPhone 4 (56) iPhone 4S (31) iPhone apps (34) iphone OS (15) ipod (42) iPod Touch (25) IPTV (12) ISPs (23) iTunes (48) Ivy Bridge (17) Julia Gillard (12) Kevin Rudd (65) keyboards (10) kindle (23) Kindle 2 (12)

Internet filtering (6

an Android Virtual Device for the 2.2 release with 256MB SD Card

rtual Machine that you have created. The first time you start a virtual device, it takes several minutes and may utes (see Figure 16). If the snapshot feature is enabled, the next start up will be a much faster process. Why so evice creates a full features ARM powered virtual hardware machine, then installs the operating system on that nd then it boots up. Google has promised to optimise this process in future releases.

iTunes Store (18)

Kogan (17) Labor (10) laptops (56) Law (15) Lawsuit (40) lawsuits (27) LCD (23) legal (10) Lenovo (51) LG (30) Lifebook (11) Linux (332) Mac (312) Mac Mini (10) Mac OS (47) Mac Pro (12) MacBook (35)

LCD Monitors (10

Legal threats (12)

MacBook Air (43) Malware (17) Mapping (21) Maps (14) Marketing (33) media (21)

MacBook Pro (42

al boot-up is a very slow process and will last several minutes. Go ahead, take a break and enjoy your favourite

Master Builder (10

Media Centre (60 MeeGo (15) Memory (17) microarchitecture Microsoft (587) MID (14) mini-note (16) Mobile apps (37)

boots up and launches, you will be presented with an initial screen where you can explore the virtual Android new to Android, click the grid icon (bottom centre) to see the applications installed by default in the virtual

media player (19)

Michael Malone (1

Microsoft Office (1

Mobile broadband

mobile computing

Mobile networks (

Mobile operating s

Mobile OSes (67) MobileMe (12) Mobiles (219) Mobility (146) Moblin (14) money (21) monitor (17) monitors (33)

mobile phones (10

motherboard (13) Motorola (27) movies (64) Mozilla (28) MP3 (12) MSI (46) multicore (16) multimedia (25) Multitouch (20) Music (52) Naked DSL (11) NAS (26) navigation (23) NBN (53) Nehalem (28) net filtering (11) netbook (117) Netbooks (248) netpads (11) Networking (29) Next G (98) Nintendo (11) Nokia (49) notebook (80) Notebook Hunter Notebooks (385) NVIDIA (88) OCZ (10) Office (36) Office 2010 (19) OneNote (11)

Motherboards (41

art screen of the virtual Android Device.

APC Magazine in the Google search bar inside the Virtual Android device. If your network connection is onnect to the net and complete the search (see Figure 18). Press the back button (the one with the curved hand panel) to return to the home screen.

Networking & Com

Online Auctions (2 Online fraud (21)

online marketplac

Online shopping ( operating system Optus (167) OS (30) os x (17) OSes (243) Outlook (13) overclocking (29) P2P (22) Palm (18) Panasonic (13) Parallels (11) patents (10) PayPal (19) PC cases (19) PCs (150) Peripherals (45) phones (168) Piracy (53) Politics (34)

open source (211

operating systems

patent warfare (12

PC Hardware (35

nside the Android Emulator

Platforms & Tools

re the various menu options from the Home screen. If you press the Menu button, these options will come up Porn (12) t of the screen (see Figure 19). Explore the settings panel, or add additional widgets using the Add option. You portable media (1 e the option in the contextual menu in the browser as well.

PowerPoint (15) prepaid (25) Pricing (127) printers (32) Privacy (20) processor (32) PVRs (21) qantas (12) Quad Core (14) Quad-Core (14) RAM (16)

programming (19)

research (14) retail (21) retailers (11) RIM (100) routers (12) safari (19) Sales (12) Samsung (115) Satellite (10) satire (26) Seagate (19) search (18)

Sandy Bridge (40

search engine (16 Second Life (18) Security (67) SEO (15) Server (10)

search engines (1

Server Masterclas Servers (38) Sex (29) SFF (10) Shuttle (12) Skype (21) Slate (30) slates (30) smartphone (39)

Server OSes (24)

devices offer a contextual menu for most screens.

wn the emulator, and the SDK manager. We need to do this before installing the Eclipse Android plug-in.

Small Biz Big IT (1

ng Eclipse IDE | Next: Installing the Eclipse Android plugin

smartphone opera

Smartphones (578 Software (235) Sol Trujillo (17) solid state drives Sony (69) Spam (15) Speed (26) SSD (61)

Social networking

software licensing

oid Java Development Kit Eclipse IDE Eclipse Android plugin

e Android development environment

Sony Ericsson (20

Android SDK

on Android

ndex

reply

Stephen Conroy ( Steve Jobs (32) storage (77) Streaming (66) Sun (11) Symbian (24) Sync (16) Tablets (234) Tech.Ed (13) Telstra (250) theft (10) thin (10) Thinkpad (17) Three (73) Tivo (12) Toshiba (56) Touch (22)

Steve Ballmer (16

Sun VirtualBox (1

d: worth getting excited about?

eresting Google Android apps

oogle Android expert Dan Morrill spills all

d phones delayed, but HTC promises this year

s mobile phone: new details of Android

Telecommunicatio

s about

Telstra Next G (23

RSSEmail Alert

mail Alert

thin and light (12)

Touch Screen (13 Travel (26) TV (93) TVs (23) Twitter (42) Ubuntu (62) Ultra (12) Ultrabooks (27) ultraportable (60)

Touchscreen (73)

alerts for new comments posted in this article

Ultimate iPhone U

RSS feed

Email alert

ultra portable (10)

ultraportable note UlV (15) UMPCs (20) upgrade (21) USB (31) USB 2.0 (11)

Ultraportables (26

ckages and it still shows no avds what did i do wrong 05 April 2012, 3:22 PM (9 months ago)report abuseSend to a friend

United States (11

 reply

USB 3.0 (19) VAIO (22) VHA (39) VIA (10) video (56) VirtualBox (11)

ckages and it still shows no avds what did i do wrong 05 April 2012, 3:24 PM (9 months ago)report abuseSend to a friend

Virgin Mobile (14)

Virtualisation (14) Viruses (13) Vista (18) VMware (16) Vodafone (126) VOIP (29) web (50) Web 2.0 (47) Web apps (30)

Virtualization (28)

oach. Its quite simple to start with android development.just follow the steps in this blog to set up Android in PC, Netbeans, eclipse, blogspot.in/2012/12/configure-android-on-pc.html
01 January 2013, 5:13 AM (2 days ago)report abuseSend to a friend reply

Web Browser (16 WebOS (16) Westmere (13) WiFi (29) Wi-Fi (25) WiMax (13) Windows (705) Windows 7 (268) Windows 8 (31)

Web developmen

Western Digital (1

Westmere chip (1

Windows Home S

Windows Live (16

Windows Mobile (

Windows Mobile 6

Windows Phone (

Windows Phone 7 Windows Warrior wireless (64)

Windows Vista (3

Windows XP (99)

Wireless broadba Word (18)

wireless networkin

Workstation (11) Xbox 360 (11) Xeon (12) XPS (10) YouTube (19)

Contact Us Submit news Privacy policy RSS feeds Comment guidelines Advertise with us APC back issues About Us

Other ninemsn businesses:

Pty Ltd - All rights reserved