Google Android ADT On Linux Mint 13 (Maya)

Recently I had to task of assembling a PC and then installing the OS and other software on it for a colleague. He had also expressed his desire to start developing Android software on that PC - so, he also asked me to set it up as a development system as well.

I will not bore the readers on how I assembled the PC and installed Linux Mint 13 OS with MATE on it - suffice to say that everything works!. I now realized that I have the perfect opportunity to update my blog on Android software development with Linux Mint 13 using the latest Google ADT (Android Development Tools) bundle - which also includes the latest Android SDK and a pre-configured Eclipse IDE, using my colleague's PC. So this whole blog is on that subject - hopefully it will be of use to anyone who, like my colleague, is about to start developing Android software on a brand new PC.

Of course, the first task would have to install a Java JDK on the PC - but which Java - OpenJDK or Oracle's Java? And which version 6 or 7? Based on my past experience, I decided to go with OpenJDK 6 as I do not see any advantage of having all the 'flavors' of Java on my colleague's PC - it will only complicate matters.

These are the steps I used to set up the PC into an Android development system:

1. Open Synaptic (Menu >> Administration >> Synaptic Package Manager), enter your password for Authentication, click Close on the Quick Introduction window (if it appears) and you will be at the Synaptic main window (see below).
    
   
   
   Synaptic intro window
    
   
   
   Synaptic main window
    
2. In the Quick filter field, enter 'openjdk' and the package windows will show all the possible entries for this item (see below).
   
   
   
   Synaptic openjdk search
    
   
   
   
   Mark additional
    
   
   Mark all the packages listed below for installation (including any other additional items required):
   
      openjdk-6-jdk
      openjdk-6-demo
      openjdk-6-doc
      openjdk-6-dbg
      default-jdk
      default-jdk-doc 
   
   Click on the Apply button to start installing all the packages - be patient as it will take some time for the download and install process to finish.
    
3. To verify that the Java JDK has been successfully installed, open a terminal (Menu >> Accessories >> Terminal) and enter the following command:
   
     java -version
   
   You should get something like the following output:
   
     java version "1.6.0_24"
     OpenJDK Runtime Environment (IcedTea6 1.11.5) (6b24-1.11.5-0ubuntu1~12.04.1)
     OpenJDK Server VM (build 20.0-b12, mixed mode) 
   
   Do not close the terminal yet - you will need it later. Now that Java has been installed, the next task is to download and install the ADT Bundle from Google - follow the steps below.
    
4. The ADT Bundle can be found here (http://developer.android.com/sdk/index.html). Since my colleague's PC is a 32-bit one, I selected 'adt-bundle-linux-x86.zip' to download. If you are using the 64-bit version of Linux Mint, make sure that the 'ia32-libs' package has already been installed, then download the 'adt-bundle-linux-x86_64.zip' file.
    
5. Now unzip the downloaded file (normally to the 'Downloads' folder), by executing the following command in the terminal.
   
     unzip ~/Downloads/adt-bundle-linux-x86.zip
   or
     unzip ~/Downloads/adt-bundle-linux-x86_64.zip
   
   This will create a new folder 'adt-bundle-linux-x86' (or adt-bundle-linux-x86_64) in your home directory which will contain all the unzipped files. Under the 'adt-bundle-linux-x86' folder, there will be 2 sub-folders, one called 'eclipse' (which contains the Eclipse IDE) and the other called 'sdk' (which contains the Android SDK).
    
6. The Eclipse IDE can be started in a terminal by executing:
   
     cd adt-bundle-linux-x86/eclipse
     ./eclipse 
   
   A much better way is to create a program launcher on the desktop by first right-clicking on the desktop, and then clicking on the 'Create Launcher...' item. A 'Create Launcher' window will appear (see screen-shot below) - fill in the 'Name:', 'Command:' (browse to /home/(username)/adt-bundle-linux-x86/eclipse/) and 'Comment:' as shown. The Eclipse icon will be used by default. Click 'OK' to create the launcher - it will appear on the desktop. Double-click on it to start Eclipse.
   
   
   
   Create Eclipse launcher
    
7. Since this is the first time Eclipse is started, it will prompt you for a workspace directory (see below) - I use '/home/(username)/Projects/Android/' (where username is my login name) but you can place it anywhere you like or accept the default of /home/(username)/workspace. You can also set this as the default and not ask again - then click 'OK'.
   
   
   
   Set Eclipse workspace
   
   You may see a screen like the one shown below asking you to contribute usage statistics - choose 'Yes' or 'No' and click on the 'Finish' button.
   
   
   
   Usage stats window
   
   The Eclipse IDE will then be displayed (see below) with a welcome message from Google - close this tab when you have finished reading it.
   
   
   
   Eclipse welcome screen
   
   The main workbench of Eclipse (see below) will now be displayed.
   
   
   
   Eclipse main workbench screen
    
8. Note that Eclipse is already loaded with the Android Developer Tools plugin and the SDK is ready to develop Android software. However, we will tweak it a bit here. Click on the Window item in the menu, and select Android SDK Manager. After a while, the Android SDK Manager window (shown below) will appear. I have resized this window to show all the items.
   
   
   
   SDK manager screen
   
   Notice that both the Android SDK Tools and Android SDK Platform-tools have already been installed along with some of the files for Android SDK (API 17). You can, at this stage, download and install the rest of the files like Documentation for Android SDK, Samples for SDK, Google APIs and Sources for Android SDK but all the files needed to start developing Android software has already been installed. I do encourage, however, that the samples and documentation be downloaded and installed.
   
   To do this, place checkmarks on the 'Documentation for Android SDK' and the 'Samples for SDK' files. Then click on the 'Install 2 packages...' button. The Choose Packages to Install window will pop up (see below) - select 'Accept All' followed by clicking on the Install button. The items will start downloading - progress of the download and install process will be shown on the SDK Manager window. Once the process is completed (the status bar at the bottom will show 'Done loading packages'), close the SDK Manager.
   
   
   
   Install packages screen
    
9. You can now set up one or more Android virtual devices (which correspond to your actual Android device(s)) so that you can test the developed software to see whether they work or not on the device.
   
   Click on the Window item in the menu, and select Android Virtual Device Manager. After a while, the AVD Manager window (shown below) will appear.
   
   
   
   AVD manager window
   
   If this is the first time you are using the Android AVD Manager, there will be no virtual devices and the list of available AVD's will be empty. To create a new virtual device, click the 'New...' button.
   
   A window will appear in which you need specify what type of device you are going to create(see below). First enter the AVD Name of the device - for example 'MyJellyBean' - any name will do, as long as you remember what type of device it represent (an Android 4.2 Jelly Bean device in this case).
   
   
   
   New AVD window
   
   Next you need to specify a Device to emulate - in my case, I decided to use a 7" WSVGA Tablet as this closely resemble the actual tablet that I have in my possession.
   
   Next you need to specify the Target - i.e., the version of Android targeted - click on the right-hand downward arrow and click on a suitable one from the list. Note that this list will only contain all the versions that you have previously installed using the Android SDK Manager. In my example, there is only one - the Android 4.2 - API Level 17. The CPU/ABI will be automatically entered - in my case 'ARM (armeabi-v7a)'.
   
   Leave the Keyboard and Skin at the default. Then select a Front Camera to use by clicking on the right-hand downward arrow and click on a suitable one from the list. Since I have a webcam on my PC. I selected 'Webcam0'. Note that this item will not be listed if you do not have a webcam - if that is so, select 'Emulated' instead.
   
   For Memory Options and if you have enough RAM on your system, I suggest that you increase the RAM to greater than 768 MiB. Leave the VM Heap and Internal Storage values at the default.
   
   You can now specify the size of the SD Card to emulate (in KiB, MiB, or GiB) - in my case I entered 128 MiB. Under Emulation Options, enable 'Use Host GPU'. Leave the rest of the fields at the defaults. The final screen will look something like the one shown below.
   
   
   
   New AVD settings
   
   Click on the 'OK' button - the newly created virtual device will now appear in the AVD list (see below).
   
   
   
   New AVD created
    
10. To test whether the newly created virtual device works, select the device and click on the 'Start' button - click 'Launch' on the Launch Option window that appears next (see below). The starting emulator window will then be displayed (see below). If you see the 'Warning: No DNS servers found' message like the one shown, just ignore it for now - it will be fixed later.
    
    
    
    New AVD start
     
    
    
    AVD launch options
     
    
    
    AVD starting window
     
    After a while, the Jelly Bean Android virtual device will appear on the desktop with a flashing 'Android' figure (see below). This denotes that it is still loading - be patient.
     
    
    
    AVD loading
     
    Once the AVD has finished loading, you will be greeted with a screen similiar to the one below - just click on the OK button and the home screen will appear.
     
    
    
    AVD loaded
     
    
    
    AVD home screen
     
    Test the AVD on/off button by clicking on the power button (rightmost button on the first row). If this works, then the AVD's screen will go blank, signifying a power off condition (see below).
     
    
    
    AVD off
    
    Click on the power button again. The login screen (see below) will appear if everything works.
     
    
    
    AVD login screen
    
    Just like a real Android device, you have to slide the padlock to the right to unlock the device - do so and the Home screen will reappear.
     
11. Notice that both the 'Hardware Buttons' and the 'DPAD' on the Jelly Bean AVD has not been enabled. This means that the Home, Menu, Back and Search buttons (the second row of buttons on the AVD) as well as the DPAD (the navigation pad on the AVD) cannot be used at the moment. Try pushing any of these buttons - nothing will happen. In order to activate this (along with fixing the no DNS servers found message), follow the steps below:
     
    
    1. Close the AVD.
    2. Close the starting emulator window.
    3. Close the AVD Manager.
    4. Close Eclipse ADT.
    5. Open a terminal and execute:
            nano .android/avd/(avdname).avd/config.ini
       where (avdname) is the name of the AVD created.
    6. Change the line that reads hw.dPad to 'yes' instead of 'no'.
    7. Change the line that reads hw.mainKeys to 'yes' instead of 'no'.
    8. Save the changes and exit the editor.
    9. While in the terminal, execute:
          sudo dpkg-reconfigure resolvconf
       Select 'Yes' when prompted.
       NOTE: This will fix the 'Warning: No DNS servers found' message during the starting of the AVD. You will also be able to access the Internet in the AVD after this fix.
       Reboot the PC to make the changes.
    10. Start Eclipse ADT again.
    11. Start the AVD Manager again.
    12. Start the AVD (MyJellyBean in this example).
    
    Notice that the message 'Warning: No DNS servers found' will no longer appear during the start of the AVD. You should also see the AVD look like the one below (after loading and unlocking) - notice that both the Hardware Buttons and DPAD has been enabled.
     
    
    Fixed AVD home screen
    
    You can now play around with the AVD - close the AVD when done and then close the AVD Manager. Just remember that this is a virtual machine emulating an ARM CPU based device on an x86 PC. If you expect the virtual device to be fast, then you need to lower your expectation - try it out and see what I mean. It does, however, serves as a test bed for the applications that will be developed later.
    
    Now that you have downloaded, installed and configured all the components for developing software on the Android platform, you can start off programming with the obligatory 'Hello World' program.
     
12. Start Eclipse (if not started) and then click on the New button found in the toolbar. In the New project window that appears next (see figure below), expand the 'Android' item by clicking on the arrow to the left of the name and selecting 'Android Application Project'. Then click Next.
    
    
    
    Start new project
     
    
    
    New Android app project
     
13. Fill in the form that appears (see below) with the data shown. Note that after entering the Application Name 'My First App', the Project Name and Package Name are automatically filled in - do not change these. The 'Minimum Required SDK', 'Compile With' and 'Theme' has also been filled in with the correct data - in my case, I have only to change the Target SDK to 'API 17: Android 4.2'). Then click Next.
    
    
    
    New Android app data
    
    Click Next when the 'Configure Project' screen (see below) appears, i.e., leave everything here at their defaults.
    
    
    
    Configure project
    
    Click Next when the 'Configure Launcher Icon' screen (see below) appears.
    
    
    
    Configure launcher icon
    
    Click Next when the 'Create Activity' screen (see below) appears.
    
    
    
    Create activity
    
    Click Finish when the 'New Blank Activity' screen (see below) appears.
    
    
    
    New blank activity
    
    The main Eclipse workbench will reappear after a while (see figure below) - your first Android project has now been set up with some default files.
    
    
    
    First project workbench
    
    Note that the project that was just created includes a default "Hello World" source file that allows you to immediately run the application without having to enter any lines into your project.
     
14. Now we will test out the application on the AVD you have previously created. First, make sure that you do not have any Android device plugged into your PC (we will test it on an actual Android device later). Then click on the Run button (the green one with the white right-pointing arrow - not the one with the red toolbox) in the toolbar.
    
    A Run As window will appear (see below) - select Android Application and click OK.
    
    
    
    Run As window
    
    The program will run and the AVD login window will appear (see below) - slide to unlock and, after a while, the output of your first Android application will appear in the AVD (see below). If this the first time you are running Eclipse, you may also get an Auto Monitor Logcat window popping up as shown below. Click OK if it does.
    
    
    
    AVD login window
     
    
    
    AVD logcat window
     
    
    
    MyFirstApp output
    
    If you press the AVD's 'Home' key and then the 'Applications' icon, you can see that your My First App will also be listed in the available applications (see below).
     
    
    
    MyFirstApp listed
    
    Congratulations! You have just successfully tested MyFirstApp on the AVD. Close the AVD once you have finished admiring your work. DO NOT CLOSE ECLIPSE YET! We will now test out the same app on a real Android device - which I assume you already have one.
    
    Before you do any else, I suggest that you visit Google's Android Developer web site (http://developer.android.com/sdk/index.html), and then click on 'Tools' and 'Workflow' and finally 'Using Hardware Devices'. Acquaint yourself with the contents that appear - it gives clear instructions on how to setup and connect a device for testing during software development. The required steps for Linux Mint 13 are replicated here for your convenience.
     
15. Open a terminal and execute:
    
       sudo nano /etc/udev/rules.d/51-android.rules
    
    This will open a blank file in which you need to enter the following (all in one line):
    
      SUBSYSTEM=="usb", ATTR{idVendor}=="4-digit-number", MODE="0666", GROUP="plugdev"
     
    Replace the idVendor with a 4-digit hex number for your device - the web-page mentioned above has a list of the vendor's IDs listed there.  Find the id for the vendor of your Android device on the and enter it into the file. Save and close the file. Then execute the command:
    
      sudo chmod a+r /etc/udev/rules.d/51-android.rules
    
    As an example, for my Samsung Galaxy Tab 7.7 Tablet, I looked up the idVendor and found it to be 04e8 hex. So the line I entered looks like:
    
      SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", MODE="0666", GROUP="plugdev"
     
16. Make sure that USB debugging is enabled on your device (your real Android device - not the AVD) - the settings can normally be found at Settings >> Developer options but may vary from device to device, but it is always located in Settings.
     
17. Power on your Android device, unlock it, and the connect the device to the PC via a USB cable. You may get one or more windows pop-up asking you what to do - select 'Do nothing' in all cases and then press OK. You may also get an error message saying that Linux Mint is unable to mount the Android device - click OK to dismiss the message, i.e., we will ignore it.
    
    Now execute the following commands on the open terminal:
    
      cd adt-bundle-linux-x86/sdk/platform-tools
      ./adb devices 
    
    If your Android device has been connected correctly, you should see something like this:
    
      List of devices attached
      464119060136df1f    device 
    
    Then close the terminal.
     
18. Click on the Run button on Eclipse and a Device Chooser window (shown below) will pop up. Select the device and click OK.
    
    
    
    Device chooser
    
    After a brief period, the application will run and the same output as before will appear on the device. MyFirstApp will also appear in the Applications list of the device.
    
    NOTE 1: If nothing happens when you press the Run button, and error messages are displayed in Eclipse, starting with "The connection to adb is down, and a severe error has occured." then you need to perform the following steps to restart the adb.
    
    
    1. Close the Eclipse if it is running.
    2. Start a terminal and execute the following commands:
       
        cd adt-bundle-linux-x86/sdk/platform-tools
        ./adb kill-server
        ./adb start-server
       
       If you see the message 'daemon started successfully' on the terminal then the adb has been restarted successfully, else try again. Close the terminal after the adb has been restarted successfully.
    3. Start Eclipse again.
    4. Run the application again. It should run now.
         
    NOTE 2: If you are, like me, an Android developer developing software on different OS platforms (e.g., Linux, Windows, etc), you are likely to run into a situation where Eclipse complains that it cannot run the app because of an existing app on the device with the same name but have a different signature. The error message also suggest that the existing app on the device be removed - so just un-install the app and try running the project again. It should work now.
    
    Double Congratulations! You have just successfully tested MyFirstApp on the AVD as well on an actual Android device.
     

One last word - my colleague was extremely pleased with the new PC and is well on the way to becoming a productive (and hopefully, prolific) Android programmer.

Eclipse+Android on Linux Mint 13 (Maya)

So far, my previous blogs on Linux Mint 13 has described how to install Java and the Android SDK. If you have followed the blogs, you will now be ready for the next step towards Android software development and that is to install a Java programming environment called Eclipse. Of course, first we have to install this (if it has not been installed yet). The install process is very simple - you can use either Synaptic or the command line to carry out this job.

1. To use Synaptic, start Synaptic, enter your password, then type 'eclipse' into the search box. The entry for Eclipse will appear - mark it for installation, and the rest of the additional items, and then click on the 'Apply' button. Wait for download and install process to finish, close Synaptic and you are done!
   
   To use the command line, start a terminal, and type:
   
   sudo apt-get install eclipse
   
   Type 'Enter' when prompted, wait for the packages to be downloaded and installed, close the terminal and you are done!
   
   
2. Before you start Eclipse, you need to determine whether the necessary SWT (Standard Widget Toolkit) libraries link are set properly - else Eclipse will complain that it cannot start because it cannot find the swt library. Check the following location in you home directory for 32-bit Linux Mint by typing the following command in a terminal:
   
   ls ~/.swt/lib/linux/x86/
   
   For a 64-bit Linux Mint, the command is:
   
   ls ~/.swt/lib/linux/x86_64/
   
   If you see a message like that shown below, then the swt directory does not exist.
   
   ls: cannot access /home//.swt/lib/linux/x86/: No such file or directory
   
   To create the swt directory on a 32-bit Mint, execute:
   
   mkdir -p ~/.swt/lib/linux/x86/
   
   To create the directory on a 64-bit Mint, execute:
   
   mkdir -p ~/.swt/lib/linux/x86_64/
   
   On the other hand, if the swt directory exist, but nothing is listed (ie, no file links in that directory), then the necessary links are not set. if this is so, execute the following command:
   
   For 32-bit Mint:
   
   ln -s /usr/lib/jni/libswt-* ~/.swt/lib/linux/x86/
   
   For 64-bit Mint:
   
   ln -s /usr/lib/jni/libswt-* ~/.swt/lib/linux/x86_64/
   
   Verify that the file links are set using the ls command again - if set, you should see the following file links:
   
   libswt-atk-gtk-3740.so    libswt-cairo-gtk-3740.so
   libswt-gnome-gtk-3740.so  libswt-pi-gtk-3740.so
   libswt-awt-gtk-3740.so    libswt-glx-gtk-3740.so
   libswt-gtk-3740.so        libswt-webkit-gtk-3740.so
   
   
3. Start Eclipse, then answer the prompt (see below) to set a workspace - I use '/home/<username>/Projects/Android (where username is your login name) but you can place it anywhere you like or accept the default of /home/<username>/workspace - then click OK.
   
   
   
   
   
   Eclipse will start loading and you will then see a screen like the one shown below.
   
   
   
   
   
   Click on 'Workbench' (near top right corner of the screen) and the main workbench screen will appear (see below).
   
   
   
   
   
4. Click on Help (on the top menu bar), then on select 'Install New Software'. A new window called 'Available Software' will pop-up (see below) - click the ‘Add’ button at the top of the window. An “Add Repository” window will pop up. Pick a name, (I chose ‘ADT Plugin’ - ADT stands for Android Development Tools), then enter the following URL in the ‘Location’ box and click OK.
   
   https://dl-ssl.google.com/android/eclipse/
   
   NOTE: If you have trouble acquiring the plugin, try using "http" in the URL, instead of "https". For security reasons, https is preferred.
   
   
   
   
   
   
   
   The window will close and a 'Pending' message will appear on the Available Software window - this indicates that the software is checking the URL for the plug-ins. When this is complete, you will see the 2 items listed (see below).
   
   
   
   
   
   Select the checkbox next to Developer Tools and click Next. In the next window, you'll see a list of the tools to be downloaded (see below) - click Next. Read and accept the license agreements (see below), then click Finish. The plug-ins will be downloaded and installed.
   
   
   
   
   
   
   
   
   
   NOTE: Click OK if you get a security warning saying that the authenticity or validity of the software can't be established.
   
   At the end of this process, you will be prompted to restart Eclipse - do so. When you arrive at the main workbench, you will see a window (see below) welcoming you to Android development - here you will have to configure the Android SDK.
   
   
   
   
   
   Since we have already downloaded and installed the Android SDK (see my previous blog), all we need to do here is specify the location of the SDK which happens to be '/home/<username>/android-sdk-linux'. Then click 'Next' - the next screen (see below) will ask you whether you want to contribute to Google's usage statistics - select 'Yes' or 'No' and then press 'Finish'
   
   
   

That's it - you are now ready to start developing Android software on your Linux Mint 13. My next blog will show you a simple 'Hello, World' project, a few sample projects and will also describe some of the resources you can use to start program development on Android.

Android SDK on Linux Mint 13 (Maya)

In my previous blogs, I showed how to install various 'flavors' of Java on Linux Mint 13 - both 32 and 64 bits versions. Now I will show how to install and configure the Google Android SDK to be used together with Java, for Android software development.

1. First head over to:
   
     http://developer.android.com/sdk/index.html
   
   and download the latest (as of July 2012) file:
   
   android-sdk_r20-linux.tgz
   
   IMPORTANT NOTE:
   If you are using 64-bit Linux Mint 13 you MUST download and install the 'ia32-libs' package since the Android SDK is a 32-bit application and requires the 32 bit library to operate properly. To download and install, open a terminal and execute:
      sudo apt-get install ia32-libs
   
   
2. Start a terminal and unzip the downloaded file:
   
   tar xvf ~/Downloads/android-sdk_r20-linux.tgz
   
   This will create a new directory 'android-sdk-linux' in your home directory containing all the unzipped files. Why the home directory? The simple answer is 'to avoid file permission problems'. Note that by installing the SDK in the home directory, only the current user can access it - so security is guaranteed.
   
   If, however, you want the SDK to be accessed by other users, then you may have to install it somewhere else - perhaps the /opt directory. This article will not describe how to do that - it just assumes that the current user is the only one that can access the SDK.
   
   
3. Change directory and execute the android SDK:
   
   cd android-sdk-linux/tools
   ./android
   
   TIP: You can set the PATH environment to point to your Android SDK tools directory so that you can start the 'android' program anywhere. Edit the .profile file in your home directory and add the following lines to the end of the file:
   
     # set PATH so it includes user's Android SDK if it exists
     if [ -d "$HOME/android-sdk-linux" ] ; then
         PATH="$HOME/android-sdk-linux:$HOME/android-sdk-linux/tools:$PATH"
     fi
   This will only take effect on the next logout/login or restart.
   
   The SDK Manager will start as shown in the screenshot below.
   
   
   
   Notice the progress bar at the bottom of the screen - this indicates that the SDK Manager is querying for updates from Google. Wait this is finished - you will then notice that it automatically selects a set of recommended packages. However it seems to have missed the 'Android SDK Platform-tools' which, according to Google, is required when you install the SDK for the first time. So place a check mark on that item by clicking in the check-box. Also de-select the item 'Google APIs' since this can only be downloaded and installed AFTER all the rest of the marked item has been installed. The final screen will look like the one shown below.
   
   
   
   
4. Click on the 'Install 6 packages' button - a window will pop up (shown below) listing all the packages to be installed. Notice that the 'Accept' radio button is selected - so just press the 'Install' button to start the process of downloading and installing the packages. The progress bar at the bottom indicates the status of this process. Also a log screen may appear if there are problems during install - ignore the 'Stopping ADB server failed (code -1)' message if it appears on the log - this seems to be harmless.
   
   
   
   When install is complete, close the log windows (if open) and then place a tick mark on the 'Google APIs' item and press the 'Install 1 package' button. When the package list appears, press 'Accept', then the 'Install' button, and then wait until this package is installed. That's it - you have installed the recommended (and latest) Android packages necessary for software development. As of July 2012 this is Android 4.1(API 16) - codenamed Jelly Baby. Is it necessary to install all the other packages (API 3 to 15)? This is entirely up to you - if you really need to develop software only for an Android version, then, by all means download and install it using the SDK Manager.
   
   
5. Now we need to set up at least one AVD (Android Virtual Device) on which you can test your developed software. The AVD is an emulator which emulates the ARM processor. To set up the AVD we need to invoke the AVD Manager which is part of the SDK Manager. Click on 'Tools' (in the menu bar) and then click on the 'Manage AVDs...' item. You will the screen as shown below.
   
   
   
   
6. Click on the 'New' button - a new window will pop-up (see below). Give the new AVD a name - for example 'MyJellyBaby'. Select 'Android 4.1 - API Level 16' as the target for the AVD.
   
   Then enter the size of the SD card - I use 128 MiB which should be sufficient for testing. Leave the rest at default except for the 'Device ram size' under hardware. To make the AVD load a bit faster and if you have at least 4GB of system RAM, change the size to 768 by clicking on the default '512' and changing it to 768.
   
   Next to make the emulator perform even faster, enable GPU emulation by clicking the 'New...' button and then click on the double arrow on the 'Property:' button and select 'GPU emulation' from the list. Then click on the value item and change it to 'yes'.
   
   The final screen will look like the one shown below. Then click on the 'Create AVD' button.If there are no errors, you will see a screen like the one below. Press 'OK' - the AVD list will then show the new AVD - MyJellyBaby in this case (see figure).
   
   
   
   
   
   
   
   
7. To start the AVD, first select it on the list, then click the 'Start' button - a window will pop-up (see below). You can set the display size and wipe the user data from here if you wish - then click on the 'Launch' button. You will see a 'Starting Android Emulator' screen (see below) and then the emulator will start loading as shown. Note the 'flashing' Android sign while the emulator is loading.
   
   
   
   
   
   
   
   
8. While the emulator is loading (may take time depending on the RAM size set and the speed of your system CPU and GPU), a 'thank-you' windows from Google will pop-up (see below) - if you wish you can agree to send usage statistic to Google - then click on 'Proceed' to dismiss the window.
   
   
   
   After a while the Android 4.1 'JellyBaby' emulator will appear (see below). The emulator's screen is blank except for 3 notifications on the top right-hand screen. To 'start' the emulator for the first time, click the 'power' button on the right side (above the keyboard) to switch off and then click on it again to power on. The login screen will appear (see below) - slide (using the mouse) to unlock the device. The 'Home' help screen will appear (see below) - click on 'OK' on the help screen and the actual Home screen will be shown (see below).
   
   
   
   
   
   
   
   
   
   
9. You can play with the emulator at this stage - close the main window when done. Then close the 'Starting Android Emulator' screen. To dismiss the AVD list, press the 'Esc' key and you will be beck at the Android SDK Manager window. Close it if you wish.

That's it - you now have a working Android SDK and you are now almost ready to start developing Android software on your Linux Mint 13. The next blog will describe installing Eclipse - a programming environment for developing Java programs - and with the help of several Google plugins for Eclipse - a programming environment for developing Android programs as well.