Android NDK Beginner's Guide

4 (2 reviews total)
By Sylvain Ratabouil
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Setting Up your Environment

About this book

Android NDK is all about injecting high performance into your apps. Exploit the maximum power of these mobile devices using high-performance and portable code.

This book will show you how to create C/C++ enabled applications and integrate them with Java. You will learn how to access native API and port libraries used in some of the most successful Android applications.

Using this practical step-by-step tutorial, highlighted with comments and tricks, discover how to run C/C++ code embedded in a Java application or in a standalone application. You will create a real native application starting from project creation through to full implementation of native API and the porting of existing third-party libraries. You will discover OpenGL ES and OpenSL ES, which are becoming the new standard in mobility. You will also understand how to access keyboard and input peripherals and how to read accelerometer or orientation sensors.

Finally, you will dive into more advanced topics such as debugging and troubleshooting applications. By the end of the book, you should know the key elements to enable you to start exploiting the power and portability of native code.

Publication date:
January 2012
Publisher
Packt
Pages
436
ISBN
9781849691529

 

Chapter 1. Setting Up your Environment

Are you ready to take up the mobile challenge? Is your computer switched on, mouse and keyboard plugged in, and screen illuminating your desk? Then let’s not wait a minute more!

In this first chapter, we are going to do the following:

  • Download and install the necessary tools to develop applications using Android

  • Set up a development environment

  • Connect and prepare an Android device for development

 

Getting started with Android development


What differentiates mankind from animals is the use of tools. Android developers, this authentic species you are about to belong to, are no different!

To develop applications on Android, we can use any of the following three platforms:

  • Microsoft Windows PC

  • Apple Mac OS X

  • Linux PC

Windows 7, Vista, Mac OS X, and Linux systems are supported in both 32 and 64-bit versions, but Windows XP in 32-bit mode only. Only Mac OS X computers of version 10.5.8 or later and based on Intel architectures are supported (not PowerPC processors). Ubuntu is supported only from version 8.04 (Hardy Heron).

Right, this is a good start but unless you are able to read and write binary language like English, having an OS is not enough. We also need software dedicated to Android development:

  • The JDK (Java Development Kit)

  • The Android SDK (Software Development Kit)

  • The Android NDK (Native Development Kit)

  • An IDE (Integrated Development Environment): Eclipse

Android, and more specifically Android NDK compilation system is heavily based on Linux. So we also need to set up some utilities by default, and we need to install one environment that supports them: Cygwin (until NDK R7). This topic is covered in detail later in the chapter. Finally, a good old command-line Shell to manipulate all these utilities is essential: we will use Bash (the default on Cygwin, Ubuntu, and Mac OS X).

Now that we know what tools are necessary to work with Android, let’s start with the installation and setup process.

Note

The following section is dedicated to Windows. If you are a Mac or Linux user, you can immediately jump to tting up Mac OS X or tting up Linux section.

 

Setting up Windows


Before installing the necessary tools, we need to set up Windows to host our Android development tools properly.

 

Time for action – preparing Windows for Android development


To work with the Android NDK, we need to set up a Cygwin Linux-like environment for Windows:

Tip

Since NDK R7, Cygwin installation is not required anymore (steps 1 to 9). The Android NDK provides additional native Windows binaries (for example, ndk-build.cmd).

  1. Go to http://cygwin.com/install.html.

  2. Download setup.exe and execute it.

  3. Select Install from Internet.

  4. Follow the wizard screens.

  5. Select a download site from where Cygwin packages are going to be downloaded. Consider using a server in your country:

  6. When proposed, include Devel/make and Shells/bash packages:

  7. Follow the installation wizard until the end. This may take some time depending on your Internet connection.

  8. After installation, launch Cygwin. Your profile files get created on first launch.

  9. Enter the following command to check if Cygwin works:

    $ make –version
    

To run Eclipse and allow compilation of Android Java code to bytecode, a Java Development Kit is required. On Windows, the obvious choice is the Oracle Sun JDK:

  1. Go to the Oracle website and download the latest Java Development Kit: http://www.oracle.com/technetwork/java/javase/downloads/index.html.

  2. Launch the downloaded program and follow the installation wizard. At the end of the installation, a browser is opened asking for JDK registration. This step is absolutely not compulsory and can be ignored.

  3. To make sure the newly installed JDK is used, let’s define its location in environment variables. Open the Windows Control panel and go to the System panel (or right-click on Computer item in the Windows Start menu and select Properties). Then go to Advanced system settings. The System Properties window appears. Finally, select Advanced tab and click on the Environment Variables button.

  4. In the Environment Variables window, inside the System variables list, insert the JAVA_HOME variable with JDK installation directory as value and validate. Then edit PATH (or Path) and insert the %JAVA_HOME%\bin directory before any other directory and separate it with a semicolon. Validate and close the window.

  5. Open a command-line window and key in java –version to check the installation. The result should be similar to the following screenshot. Check carefully to make sure that the version number corresponds to the version of the newly installed JDK:

    $ java –version
    

To compile projects from the command line, the Android SDK supports Ant—a Java-based build automation utility. Let’s install it:

  1. Go to http://ant.apache.org/bindownload.cgi and download Ant binaries, packed within a ZIP archive.

  2. Unzip Ant in the directory of your choice (for example, C:\Ant).

  3. Go back to the Environment Variables window, as in step 12, and create the ANT_HOME variable with the Ant directory as the value. Append the %ANT_HOME%\bin directory to PATH:

  4. From a classic Windows terminal, check the Ant version to make sure it is properly working:

What just happened?

We have prepared Windows with the necessary underlying utilities to host Android development tools: Cygwin and Java Development Kit.

Cygwin is an open source software collection that allows the Windows platform to emulate a Unix-like environment. It aims at natively integrating software based on POSIX standard (such as Unix, Linux, and so on) into Windows. It can be considered as an intermediate layer between applications originated from Unix/Linux (but natively recompiled on Windows) and the Windows OS itself.

We have also deployed a Java Development Kit in version 1.6 and checked if it is properly working from the command line. Because Android SDK uses generics, the JDK in version 1.5 is the least required when developing with Android. JDK is simple to install on Windows but it is important to make sure a previous installation, such as JRE (Java Runtime Environment, which aims at executing applications but not developing them) is not interfering. This is why we have defined JAVA_HOME and PATH environment variables to ensure proper JDK is used.

Finally, we have installed Ant utility that we are going to use in the next chapter to build projects manually. Ant is not required for Android development but is a very good solution to set up a continuous integration chain.

Tip

Where is Java’s home?

Defining the JAVA_HOME environment variable is not required. However, JAVA_HOME is a popular convention among Java applications, Ant being one of them. It first looks for the java command in JAVA_HOME (if defined) before looking in PATH. If you install an up-to-date JDK in another location later on, do not forget to update JAVA_HOME.

 

Installing Android development kits on Windows


Once JDK is installed on our system, we can start installing Android SDK and NDK to create, compile, and debug Android programs.

 

Time for action – installing Android SDK and NDK on Windows


  1. Open your Web browser and go to http://developer.android.com/sdk. This web page lists all available SDKs, one for each platform.

  2. Download Android SDK for Windows, packaged as an Exe installer.

  3. Then, go to http://developer.android.com/sdk/ndk and download the Android NDK (not SDK!) for Windows, packaged as a ZIP archive this time.

  4. Execute Android SDK installer. Select an appropriate installation location (for example, C:\Android\android-sdk), knowing that Android SDK and NDK together can take more than 3 GB of disk space (currently!) with all official API versions installed. As a precaution, avoid leaving any space in the target installation path.

  5. Follow the installation wizard until the end. Check the Start SDK Manager:

  6. The Android SDK and AVD Manager is launched. The Package installation window appears automatically.

  7. Check the Accept All option and click on Install to start the installation of Android components:

  8. After a few minutes, all packages get downloaded and a message asking to restart ADB service (the Android Debug Bridge) appears. Validate by clicking on Yes.

  9. Close the application.

  10. Now, unzip Android NDK archive into its final location (for example, C:\Android\android-ndk). Again, avoid leaving any space in the installation path (or some problems could be encountered with Make).

    To easily access Android utilities from the command line, let’s define the environment variables:

  11. Open the Environment Variables system window, as we did in the previous part. Inside the System variables list, insert the ANDROID_SDK and ANDROID_NDK variables with the corresponding directories as values.

  12. Append %ANDROID_SDK%\tools, %ANDROID_SDK%\platform-tools and %ANDROID_NDK%, all separated by a semicolon, to your PATH.

  13. All the Windows environment variables should be imported automatically by Cygwin when launched. Let’s verify this by opening a Cygwin terminal and checking whether NDK is available:

    $ ndk-build –-version
    
  14. Now, check the Ant version to make sure it is properly working on Cygwin:

    $ ant -version
    

    The first time Cygwin should emit a surprising warning: paths are in MS-DOS style and not POSIX. Indeed, Cygwin paths are emulated and should look similar to /cygdrive/<Drive letter>/<Path to your directory with forward slashes>. For example, if Ant is installed in c:\ant, then the path should be indicated as /cygdrive/c/ant.

  15. Let’s fix this. Go to your Cygwin directory. There, you should find a directory named home/<your user name> containing a .bash_profile. Open it in edition.

  16. At the end of the script, translate the Windows environment variables into Cygwin variables with the cygpath utility. PATH does not need to be translated as this essential variable is processed automatically by Cygwin. Make sure to use the prime character (`) (to execute a command inside another), which has a different meaning than the apostrophe (‘) (to define a variable) with Bash. An example .bash_profile is provided with this book:

    export ANT_HOME=`cygpath –u "$ANT_HOME"`
    export JAVA_HOME=`cygpath –u "$JAVA_HOME"`
    export ANDROID_SDK=`cygpath –u "$ANDROID_SDK"`
    export ANDROID_NDK=`cygpath –u "$ANDROID_NDK"`
  17. Reopen a Cygwin window and check the Ant version again. No warning is issued this time:

    $ ant -version
    

What just happened?

We have downloaded and deployed both Android SDK and NDK and made them available through command line using environment variables.

We have also launched the Android SDK and AVD manager, which aims at managing SDK components installation, updates, and emulation features. This way, new SDK API releases as well as third-party components (for example, Samsung Galaxy Tablet emulator, and so on) are made available to your development environment without having to reinstall the Android SDK.

If you have trouble connecting at step 7, then you may be located behind a proxy. In this case, Android SDK and AVD manager provide a Settings section where you can specify your proxy settings.

At step 16, we have converted the Windows paths defined inside the environment variables into Cygwin paths. This path form, which may look odd at first, is used by Cygwin to emulate Windows paths as if they were Unix paths. Cygdrive is similar to a mount or media directory on Unix and contains every Windows drive as a plugged file system.

Tip

Cygwin paths

The rule to remember while using paths with Cygwin is that they must contain forward slashes only and the drive letter is replaced by /cygdrive/[Drive Letter]. But beware, file names in Windows and Cygwin are case-sensitive, contrary to real Unix systems.

Like any Unix system, Cygwin has a root directory named slash (/). But since there is no real root directory in Windows, Cygwin emulates it in its own installation directory. In a Cygwin command line, enter the following command to see its content:

$ ls /

These files are the ones located in your Cygwin directory (except /proc, which is an in-memory directory). This explains why we updated .bash_profile in the home directory itself, which is located inside the Cygwin directory.

Utilities packaged with Cygwin usually expect Cygwin-style paths, although Windows-style paths work most of the time. Thus, although we could have avoided the conversion in .bash_profile (at the price of a warning), the natural way to work with Cygwin and avoid future troubles is to use Cygwin paths. However, Windows utilities generally do not support Cygwin paths (for example, java.exe), in which case, an inverse path conversion is required when calling them. To perform conversion, cygpath utility provides the following options:

  • -u: To convert Windows paths to Unix paths

  • -w: To convert Unix paths to Windows paths

  • -p: To convert a list of paths (separated by ; on Windows and : on Unix)

Still at step 17, you may have some difficulties when editing .bash_profile: some weird square characters may appear and the entire text is on one very long line! This is because it is encoded using Unix encoding. So use a Unix compatible file editor (such as Eclipse, PSPad, or Notepad++) when editing Cygwin files. If you already got into trouble, you can use either your editor End-Of-Line conversion feature (Notepad++ and PSPad provide one) or apply command-line dos2unix utility (provided with Cygwin) on the incriminated file.

Tip

Char return on Cygwin

Unix files use a simple line-feed character (better known as \n) to indicate an end of line whereas Windows uses a carriage return (CR or \r) plus a line feed. MacOS, on the other hand, uses a carriage return only. Windows newline markers can cause lots of trouble in Cygwin Shell scripts, which should be kept in Unix format.

Note

This is the end of the section dedicated to Windows setup. If you are not a Mac o user, you can jump to the Setting up Eclipse development environment section.

 

Setting up Mac OS X


Apple computers and Mac OS X have a reputation for being simple and easy to use. And honestly, this adage is rather true when it comes to Android development. Indeed, Mac OS X is based on Unix, well adapted to run the NDK toolchain, and a recent JDK is already installed by default. Mac OS X comes with almost anything we need with the exception of Developer Tools, which need to be installed separately. These Developer Tools include XCode IDE, many Mac development utilities, and also some Unix utilities, such as Make and Ant.

 

Time for action – preparing Mac OS X for Android development


All developer tools are included in XCode installation package (version 4, at the time this book was written). There exist four solutions to get this package, and they are as follows:

  • If you have Mac OS X installation media, open it and look for the XCode installation package

  • XCode is also provided on the AppStore for free (but this has changed recently and may change in the future too)

  • XCode can also be downloaded from the Apple website with a paying program subscription at the address http://developer.apple.com/xcode/

  • Older version 3, compatible with Android development tools, is available for free as a disc image from the same page with a free Apple Developer account

Using the most appropriate solution for your case, let’s install XCode:

  1. Find your XCode installation package and run it. Select the UNIX Development option when the customization screen appears. Finish installation. We are done!

  2. To develop with Android NDK, we need the Make build tool for native code. Open a terminal prompt and ensure Make correctly works:

    $ make --version
    
  3. To run Eclipse and allow compilation of Android Java code to bytecode, Java Development Kit is required. Let’s check if the default Mac OS X JDK works fine:

    $ java –version
    
  4. To compile projects from the command line, the Android SDK supports Ant,a Java-based build automation utility. Still in a terminal, ensure Ant is correctly installed:

    $ ant –version
    

What just happened?

We have prepared our Mac OS X to host Android development tools. And as usual with Apple, that was rather easy!

We have checked if Java Development Kit in version 1.6 is properly working from the command line. Because Android SDK uses generics, a JDK in version 1.5 is the least required for Android development.

We have installed Developer Tools, which include Make—to run the NDK compiler—and Ant—that we are going to use in the next chapter to build projects manually. Ant is not required for Android development but is a very good solution to set up a continuous integration chain.

 

Installing Android development kits on Mac OS X


Once a JDK is installed on your system, we can start installing Android Development SDK and NDK to create, compile, and debug Android programs.

 

Time for action – installing Android SDK and NDK on Mac OS X


  1. Open your web browser and go to http://developer.android.com/sdk. This web page lists all available SDKs, one for each platform.

  2. Download Android SDK for Mac OS X, which is packaged as a ZIP archive.

  3. Then, go to http://developer.android.com/sdk/ndk and download the Android NDK (not SDK!) for Mac OS X, packaged as a Tar/BZ2 archive this time.

  4. Uncompress the downloaded archives separately into the directory of your choice (for example, /Developer/AndroidSDK and /Developer/AndroidNDK).

  5. Let’s declare these two directories as environment variables. From now on, we will refer to these directories as $ANDROID_SDK and $ANDROID_NDK throughout this book. Assuming you use the default Bash command-line shell, create or edit your .profile file (be careful, this is a hidden file!) in your home directory and add the following variables:

    export ANDROID_SDK="<path to your Android SDK directory>"
    export ANDROID_NDK="<path to your Android NDK directory>"
    export PATH="$PATH:$ANDROID_SDK/tools:$ANDROID_SDK/platform-tools:$ANDROID_NDK"

    Tip

    Downloading the example code

    You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have the files e-mailed directly to you.

  6. Save the file and log out from your current session.

  7. Log in again and open a terminal. Enter the following command:

    $ android
  8. The Android SDK and AVD Manager window shows up.

  9. Go to the Installed packages section and click on Update All:

  10. A package selection dialog appears. Select Accept All and then Install.

  11. After few minutes, all packages get downloaded and a message asking to restart ADB service (the Android Debug Bridge) appears. Validate by clicking on Yes.

  12. You can now close the application.

What just happened?

We have downloaded and deployed both Android SDK and NDK and made them available through the command line using environment variables.

Tip

Mac OS X and environment variables

Mac OS X is tricky when it comes to environment variables. They can be easily declared in a .profile for applications launched from a terminal, as we just did. They can also be declared using an environment.plist file for GUI applications, which are not launched from Spotlight. A more powerful way to configure them is to define or update /etc/launchd.conf system file (see http://developer.apple.com/).

We have also launched the Android SDK and AVD manager, which aims at managing the installation, updates, and emulation features of the SDK components. This way, new SDK API releases as well as third-party components (for example, Samsung Galaxy Tablet emulator, and so on) are made available to your development environment without having to reinstall the Android SDK.

If you have trouble connecting at step 9, then you may be located behind a proxy. In this case, Android SDK and AVD manager provide a Settings section where you can specify your proxy settings.

Note

This is the end of the section dedicated to Mac OS X setup. If you are not a Linux user, you can jump to the Setting up Eclipse development environment section.

 

Setting up Linux


Although Linux is more naturally suited for Android development, as the Android toolchain is Linux-based, some setup is necessary as well.

 

Time for action – preparing Ubuntu Linux for Android development


To work with Android NDK, we need to check and install some system packages and utilities:

  1. First, Glibc (the GNU C standard library, in version 2.7 or later) must be installed. It is usually shipped with Linux systems by default. Check its version using the following command:

    $ ldd -–version
    
  2. We also need the Make build tool for native code. Installation can be performed using the following command:

    $ sudo apt-get install build-essential
    

    Alternatively, Make can be installed through Ubuntu Software Center. Look for build-essential in the dedicated search box and install the packages found:

    Package build-essential contains a minimal set of tools for compilation and packaging on Linux Systems. It also includes GCC (the GNU C Compiler), which is not required for standard Android development as Android NDK already packages its own version.

  3. To ensure that Make is correctly installed, type the following command. If correctly installed, the version will be displayed:

    $ make --version
    

Tip

Special note for 64-bit Linux owner

We also need 32-bit libraries installed to avoid compatibility problems. This can be done using the following command (to execute in a command-line prompt) or again the Ubuntu Software Center:

sudo apt-get install ia32-libs

To run Eclipse and allow compilation of Android Java code to bytecode, Java Development Kit is required. We need to download and install Oracle Sun Java Development Kit. On Ubuntu, this can be performed from the Synaptic Package Manager:

  1. Open Ubuntu System/Administration menu and select Synaptic Package Manager (or open your Linux package manager if you use another Linux distros).

  2. Go to the Edit | Software Sources menu.

  3. In the Software Sources dialog, open the Other Software tab.

  4. Check the Canonical Partners line and close the dialog:

  5. Package cache synchronizes automatically with the Internet, and after a few seconds or minutes some new software is made available in the Canonical Partners section.

  6. Find Sun Java™ Development Kit (JDK) 6 (or later) and click on Install. You are also advised to install Lucida TrueType fonts (from the Sun JRE), the Java(TM) Plug-in packages.

  7. Accept the license (after reading it carefully of course!). Be careful as it may open in the background.

  8. When installation is finished, close Ubuntu Software Center.

  9. Although Sun JDK is now installed, it is not yet available. Open JDK is still used by default. Let’s activate Sun JRE through the command line. First, check available JDK:

    $ update-java-alternatives –l
    
  10. Then, activate the Sun JRE using the identifier returned previously:

    $ sudo update-java-alternatives –s java-6-sun
    
  11. Open a terminal and check that installation is OK by typing:

    $ java –version
    

The Android SDK supports Ant, a Java-based build automation utility, to compile projects from the command line. Let’s install it.

  1. Install Ant with the following command or with the Ubuntu Software Center:

    $ sudo apt-get install ant
    
  2. Check whether Ant is properly working:

    $ ant --version
    

What just happened?

We have prepared our Linux operating system with the necessary utilities to host Android development tools.

We have installed a Java Development Kit in version 1.6 and checked if it is properly working from the command line. Because Android SDK uses generics, the JDK in version 1.5 is the least required for Android development.

You may wonder why we bothered with the installation of Sun JDK while Open JDK is already ready to use. The reason is simply that Open JDK is not officially supported by Android SDK. If you want to avoid any possible interaction with Open JDK, think about removing it entirely from your system. Go to the Provided by Ubuntu section in the Ubuntu Software Center and click on Remove for each OpenJDK line. For more information, look for the official Ubuntu documentation: http://help.ubuntu.com/community/Java.

Finally, we have installed Ant utility that we are going to use in the next chapter to build projects manually. Ant is not required for Android development but is a very good solution to set up a continuous integration chain.

Note

There is no more Sun JDK on Linux repositories since Java 7. The Open JDK becomes the official Java implementation.

 

Installing Android development kits on Linux


Once JDK is installed on your system, we can start installing Android Development SDK and NDK to create, compile, and debug Android programs.

 

Time for action – installing Android SDK and NDK on Ubuntu


  1. Open your web browser and go to http://developer.android.com/sdk. This web page lists all available SDKs, one for each platform.

  2. Download Android SDK for Linux, which is packaged as a Tar/GZ archive.

  3. Then, go to http://developer.android.com/sdk/ndk and download the Android NDK (not SDK!) for Linux, packaged as a Tar/BZ2 archive this time.

  4. Uncompress the downloaded archives separately into the directories of your choice (for example, ~/AndroidSDK and ~/AnroidNDK). On Ubuntu, you can use Archive Manager (right-click on the archive file and Extract Here).

  5. Let’s declare these two directories as environment variables. From now on, we will refer to these directories as $ANDROID_SDK and $ANDROID_NDK throughout this book. Assuming you use a Bash command-line shell, edit your .profile file (be careful, this is a hidden file!) in your home directory and add the following variables:

    export ANDROID_SDK="<path to your Android SDK directory>"
    export ANDROID_NDK="<path to your Android NDK directory>"
    export PATH="$PATH:$ANDROID_SDK/tools:$ANDROID_SDK/platform-tools:$ANDROID_NDK"
  6. Save the file and log out from your current session.

  7. Log in again and open a terminal. Enter the following command:

    $ android
    
  8. The Android SDK and AVD Manager window shows up.

  9. Go to the Installed packages section and click on Update All:

  10. A package selection dialog appears. Select Accept All and then Install.

  11. After a few minutes, all packages get downloaded and a message asking to restart ADB service (the Android Debug Bridge) appears. Validate by clicking on Yes.

  12. You can now close the application.

What just happened?

We have downloaded and deployed both Android SDK and NDK and made them available through the command line using environment variables.

We have also launched the Android SDK and AVD manager, which aims at managing the installation, updates, and emulation features of the SDK components. This way, new SDK API releases as well as third-party components (for example, Samsung Galaxy Tablet emulator, and so on) are made available to your development environment without having to reinstall Android SDK.

If you have trouble connecting at step 9, then you may be located behind a proxy. In this case, Android SDK and AVD manager provide a Settings section where you can specify your proxy settings.

Note

This is the end of the section dedicated to the Linux setup. The following section is mixed.

 

Setting up the Eclipse development environment


Command line lovers, vi fanatics, please go to the next chapter or you may feel sick! For most humans, having a comfortable and visual-friendly IDE is essential. And hopefully, Android works with the greatest of all: Eclipse!

Eclipse is the only officially supported IDE for Android SDK through the Google official plugin named ADT. But ADT is only for Java. Hopefully, Eclipse supports C/C++ as well through CDT, a general C/C++ plugin. Although not specific to Android, it works well with the NDK. The version of Eclipse used throughout this book is Helios (3.6).

 

Time for action – installing Eclipse


  1. Open your web browser and go to http://www.eclipse.org/downloads/. This web page lists all available Eclipse packages: for Java, J2EE, C++.

  2. Download Eclipse IDE for Java Developers.

  3. Extract the downloaded Tar/GZ file (on Linux and Mac OS X) or ZIP file (on Windows) with your archive manager.

  4. Once extracted, run Eclipse by double-clicking on the eclipse executable inside its directory. On Mac OS X, make sure to execute eclipse alias and not Eclipse.app or else environment variables defined earlier in .profile will not be available to Eclipse.

  5. If Eclipse asks for a workspace, define a custom workspace directory if you want to (default workspace is fine) and click OK.

  6. After Eclipse has started, close the Welcome Page.

  7. Go to the Help | Install New Software menu.

    Tip

    If a problem occurs in the next steps while accessing update sites, then check your Internet connection. You may be either disconnected or your computer is behind a proxy. In the latter case, it is possible to download ADT plugin as an archive file from the ADT web page and install it manually (or configure Eclipse to connect through a proxy but that is another matter).

  8. Enter https://dl-ssl.google.com/android/eclipse/ in the Work with field and validate.

  9. After a few seconds, a Developer Tools plugin appears; select it and click on the Next button.

  10. Follow the wizard and accept conditions when asked. On the last wizard page, click on Finish.

  11. ADT gets installed. A warning may appear indicating that plugin content is unsigned. Ignore it and click on OK.

  12. When finished, restart Eclipse as requested.

  13. When Eclipse is restarted, go to menu Window | Preferences (Eclipse | Preferences on Mac OS X) and go to the Android section.

  14. Click on Browse and select the path to your Android SDK directory.

  15. Validate preferences.

  16. Go back to the Help | Install New Software... menu.

  17. Open the Work with combobox and select the item containing Eclipse version name (here Helios).

  18. Find Programming Languages in the plugin tree and open it.

  19. Select CDT plugins. Incubation plugins are not essential. C/C++ Call Graph Visualization is for Linux only and cannot be installed on Windows or Mac OS X:

  20. Follow the wizard and accept conditions when asked. On the last wizard page, click on Finish.

  21. When finished, restart Eclipse.

What just happened?

Eclipse is now installed and official Android development plugin ADT and C/C++ plugin CDT are installed. ADT refers to the Android SDK location.

The main purpose of ADT is to ease integration of Eclipse with SDK development tools. It is perfectly possible to develop in Android without an IDE using command line only. But automatic compilation, packaging, deployment, and debugging are addictive features, which are hard to get rid of!

You may have noticed that no reference to the Android NDK is given to ADT. This is because ADT works for Java only. Hopefully, Eclipse is flexible enough to handle hybrid Java/C++ projects! We will talk about that further when creating our first Eclipse project.

In the same way, CDT allows easy integration of C/C++ compilation features into Eclipse. We also "silently" installed JDT, the Java plugin for Eclipse. It is embedded in the Eclipse IDE for Java Developers package. An Eclipse package including only CDT is also available on the Eclipse Website.

Tip

More on ADT

ADT update site given to Eclipse in step 8 comes from the official ADT documentation that you can find at http://developer.android.com/sdk/eclipse-adt.html. This page is the main information point to visit if new versions of Eclipse or Android are released.

 

Emulating Android


Android SDK provides an emulator to help developers who do not have a device (or are impatiently waiting for a new one!) get started quickly. Let’s now see how to set it up.

 

Time for action – creating an Android virtual device


  1. Open Android SDK and AVD Manager using either the command line (key in android) or the Eclipse toolbar button:

  2. Click on the New button.

  3. Give a name to this new emulated device: Nexus_480x800HDPI.

  4. Target platform is Android 2.3.3.

  5. Specify SD card size: 256.

  6. Enable snapshot.

  7. Set Built-in resolution WVGA800.

  8. Leave the Hardware section the way it is.

  9. Click on Create AVD.

  10. The newly created virtual device now appears in the list:

  11. Let’s check how it works: click on the Start button.

  12. Click on the Launch button:

  13. The emulator starts up and after a few minutes, your device is loaded:

What just happened?

We have created our Android Virtual Devices which emulate a Nexus One with an HDPI (High Density) screen of size 3.7 inches and a resolution of 480x800 pixels. So we are now able to test applications we are going develop in a representative environment. Even better, we are now able to test them in several conditions and resolutions (also called skins) without requiring a costly device.

Although this is out of the scope of this book, customizing additional options, such as the presence of a GPS, camera, and so on, is also possible when creating an AVD to test an application in limited hardware conditions. And as a final note, screen orientation can be switched with Ctrl + F11 and Ctrl + F12. Check out the Android website for more information on how to use and configure the emulator (http://developer.android.com/guide/developing/devices/emulator.html).

Tip

Emulation is not simulation

Although emulation is a great tool when developing, there are a few important points to take into account: emulation is slow, not always perfectly representative, and some features such as GPS support may be lacking. Moreover, and this is probably the biggest drawback: Open GL ES is only partially supported. More specifically, only Open GL ES 1 currently works on the emulator.

Have a go hero

Now that you know how to install and update Android platform components and create an emulator, try to create an emulator for Android Honeycomb Tablets. Using the Android SDK and AVD Manager, you will need to do the following:

  • Install Honeycomb SDK components

  • Create a new AVD which targets Honeycomb platform

  • Start the emulator and use proper screen scaling to match real tablet scale

Depending on your computer resolution, you may need to tweak AVD display scale. This can be done by checking Scale display to real size when starting the emulator and entering your monitor density (use the ? button to calculate it). If you perform well, you should obtain the new Honeycomb interface at its real scale (no worries, it is also in Landscape mode on my computer):

Note

The following section is dedicated to Windows and Mac OS X. If you are a Linux useing with an Android device on Linux section.

 

Developing with an Android device on Windows and Mac OS X


Emulators can be of really good help, but nothing compared to a real device. Hopefully, Android provides the sufficient connectivity to develop on a real device and make the testing cycle more efficient. So take your Android in hand, switch it on and let’s try to connect it to Windows or Mac OS X.

 

Time for action – setting up your Android device on Windows and Mac OS X


Installation of a device for development on Windows is manufacturer-specific. More information can be found at http://developer.android.com/sdk/oem-usb.html with a full list of device manufacturers. If you have got a driver CD with your Android device, you can use it. Note that the Android SDK also contains some Windows drivers under $ANDROID_SDK\extras\google\usb_driver. Specific instructions are available for Google development phones, Nexus One, and Nexus S at http://developer.android.com/sdk/win-usb.html.

Mac users should also refer to their Manufacturer’s instructions. However, as Mac’s ease of use is not only a legend, simply connecting an Android device to a Mac should be enough to get it working! Your device should be recognized immediately without installing anything.

Once the driver (if applicable) is installed on the system, do the following:

  1. Go to the home menu, then go to Settings | Application | Development on your mobile device (may change depending on your manufacturer).

  2. Enable USB debugging and Stay awake.

  3. Plug your device into your computer using a data connection cable (beware some cables are alimentation cables only and will not work!). Depending on your device, it may appear as a USB disk.

  4. Launch Eclipse.

  5. Open the DDMS perspective. If working properly, your phone should be listed in the Devices view:

  6. Say cheese and take a screen capture of your own phone by clicking the corresponding toolbar button:

    Now you are sure your phone is correctly connected!

What just happened?

We have connected an Android device to a computer in development mode and enabled the Stay awake option to stop automatic screen shutdown when the phone is charging. If your device is still not working, go to the Trouble shooting a device connection section.

The device and the computer communicate through an intermediate background service: the Android Debug Bridge (ADB) (more about it in the next chapter). ADB starts automatically the first time it is called, when Eclipse ADT is launched or when invoked from the command line.

Note

This is the end of the section dedicated to Windows and Mac OS X. If you are not a Linux user, you can jump to the Trouble shooting a device connection or the Summary section.

 

Developing with an Android device on Linux


Emulators can be of really good help, but it is nothing compared to a real device. Hopefully, Android provides the sufficient connectivity to develop on a real device and make the testing cycle more efficient. So take your Android in hand, switch it on and let’stry to connect it to Linux.

 

Time for action – setting up your Android device on Ubuntu


  1. Go to Home | Menu | Settings | Application | Development on your mobile device (may change depending on your manufacturer).

  2. Enable USB debugging and Stay awake.

  3. Plugin your device to your computer using a data connection cable (beware, some cables are alimentation cables only and will not work!). Depending on your device, it may appear as a USB disk.

  4. Try to run ADB and list devices. If you are lucky, your device works out of the box and the list of devices appears. In that case, you can ignore the following steps:

    $ adb devices
    
  5. If ????????? appears instead of your device name (which is likely), then ADB does not have proper access rights. We need to find your Vendor ID and Product ID. Because Vendor ID is a fixed value for each manufacturer, you can find it in the following list:

    Manufacturer

    USB Vendor ID

    Acer

    0502

    Dell

    413c

    Foxconn

    0489

    Garmin-Asus

    091E

    HTC

    0bb4

    Huawei

    12d1

    Kyocera

    0482

    LG

    1004

    Motorola

    22b8

    Nvidia

    0955

    Pantech

    10A9

    Samsung

    04e8

    Sharp

    04dd

    Sony Ericsson

    0fce

    ZTE

    19D2

    The current list of Vendor IDs can be found on the Android website at http://developer.android.com/guide/developing/device.html#VendorIds.

  6. The device Product ID can be found using the lsusb command "greped" with Vendor ID to find it more easily. In the following example, the value 0bb4 is the HTC Vendor ID and 0c87 is the HTC Desire product ID:

    $ lsusb | grep 0bb4
    

  7. With the root user, create a file /etc/udev/rules.d/52-android.rules with your Vendor and Product ID:

    $ sudo sh -c ‘echo SUBSYSTEM==\"usb\", SYSFS{idVendor}==\"<Your Vendor ID>\", ATTRS{idProduct}=\"<Your Product ID>\", MODE=\"0666\" > /etc/udev/rules.d/52-android.rules’
    
  8. Change file rights to 644:

    $ sudo chmod 644 /etc/udev/rules.d/52-android.rules
    
  9. Restart the udev service (the Linux device manager):

    $ sudo service udev restart
    
  10. Relaunch the ADB server in the root mode this time:

    $ sudo $ANDROID_SDK/tools/adb kill-server
    $ sudo $ANDROID_SDK/tools/adb start-server
    
  11. Check whether your device works by listing the devices again. If ????????? appears, or worse, nothing appears, then something went wrong in the previous steps:

    $ adb devices
    

What just happened?

We have connected an Android device to a computer in development mode and enabled the Stay awake option to stop automatic screen shutdown when the phone is charging. If your device is still not working, go to thon section.

We have also started the Android Debug Bridge (ADB), which is a background service used as a mediator for computer/device communication (more about it in the next chapter). ADB is started automatically the first time it is called, when Eclipse ADT is launched or when invoked from the command line.

And more important than anything, we have discovered that HTC means High Tech Computer! Jokes apart, the connection process can become tricky on Linux. If you belong to the unlucky group of people who need to launch ADB as the root, you are highly advised to create a startup script similar to the following one, to launch ADB. You can use it from the command line or add it to your main menu (Menu | Preferences| Main Menu on Ubuntu):

#!bin/sh
stop_command="$ANDROID_SDK/platform-tools/adb kill-server"
launch_command="$ANDROID_SDK/platform-tools/adb start-server"
/usr/bin/gksudo "/bin/bash –c ‘$stop_command; $launch_command’" | zenity –text-info –title Logs

This script displays daemon startup message in a Zenity window (a Shell toolkit to display graphical windows using GTK+).

Tip

At step 6, if 52-android.rules does not work, then try 50-android.rules or 51-android.rules (or all of them). Although udev (the Linux device manager) should only use the prefix number to order rule files lexicographically, that sometimes seems to do the trick. The magic of Linux!

Note

This is the end of the section dedicated to Linux setup. The following section is mixed.

 

Troubleshooting a development device


Having trouble connecting an Android development device to a computer can mean any of the following:

  • Your host system is not properly set up

  • Your development device is not working properly

  • The ADB service is malfunctioning

If the problem comes from your host system, check your device manufacturer instructions carefully to make sure any needed driver is correctly installed. Check the Hardware properties to see if it is recognized and turn on the USB storage mode (if applicable) to see if it is working properly. Indeed, after getting connected, your device may be visible in your hardware settings but not as a disk. A device can be configured as a Disk drive (if a SD-card or similar is included) or in charge-only mode. This is absolutely fine as the development mode works perfectly in the charge-only mode.

Disk-drive mode is generally activated from the Android task bar (USB connected item). Refer to your device documentation for the specificities of your device.

Tip

SD Card access

When the charge-only mode is activated, SD card files and directories are visible to the Android applications installed on your phone but not to your computer. On the opposite side, when Disk drive mode is activated, those are visible only from your computer. Check your connection mode when your application cannot access its resource files on a SD Card.

If problem comes from your Android device, a possible solution is to deactivate and reactivate the Debug mode on your device. This option can be switched from the Home | Menu | Settings | Application | Development screen on your mobile device (which may change depending on your manufacturer) or accessed more quickly from the Android task bar (USB debugging connected item). As a last measure, reboot your device.

Problem may also come from the ADB. In that case, check whether the ADB is working by issuing the following command from a terminal prompt:

$ adb devices

If your device is correctly listed, then ADB is working. This command will launch ADB service if it was not already. You can also restart it with commands:

$ adb kill-server
$ adb start-server

In any case, to solve a specific connection problem or get up-to-date information, visit the following web page: http://developer.android.com/guide/developing/device.html. As a feedback from experience, never neglect hardware. Always check with a second cable or device if you have one at your disposal. I once purchased a bad quality cable, which performed badly when some contortions occurred...

 

Summary


Setting up our Android development platform is a bit tedious but is hopefully performed once and for all! We have installed the necessary utilities using the package system on Linux, Developer Tools on Mac OS X, and Cygwin on Windows. Then we have deployed the Java and Android development kits and checked if they are working properly. Finally, we have seen how to create a phone emulator and connect a real phone for test purposes.

We now have the necessary tools in our hands to shape our mobile ideas. In the next chapter, we are going to handle them to create, compile, and deploy our first Android projects!

About the Author

  • Sylvain Ratabouil

    Sylvain Ratabouil is an IT consultant, experienced in Android, Java, and C/C++. He has contributed to the development of digital and mobile applications for large companies as well as industrial projects for the space and aeronautics industries. As a technology lover, he is passionate about mobile technologies and cannot live without his Android smartphone.

    Browse publications by this author

Latest Reviews

(2 reviews total)
Good
Good
Book Title
Access this book, plus 7,500 other titles for FREE
Access now