Ebook's goals

Google's new operating system for mobile devices and tablets is here! The software already has a solid reputation and is invading the world of mobile communications; it is open-source and offers programmers Java development tools. It makes mobile development accessible to all objects developers with only a small investment needed to improve their skills. The only question is: Are you ready for it?
The goal of this book is simply to allow you to be able to know and understand what are the considerations to have when you’re in charge of an Android Application as a professional. What is the test strategy to use? How can you sign your application? How can you deploy it? How can you manage the life cycle of the application? How to implement continuous integration?
This book therefore focuses on two main aspects:
• How to?
• How to conceive?
The “how to” knowledge is illustrated in the examples of Android code that are:
• presented as “barebones”, without any functional consideration
• extremely precise and specific (i.e. a project for a combo-box, one for a web kit etc) that are there only to explain a certain concept in relation to a particular example
• commented and clarified
A short paragraph describes and explains the key ideas required to understand the code and then the code finishes the demonstration by illustrating the concept. This “savoir faire” will allow you to access the different problems raised by a given concept. On certain specific subjects that are particularly complex and that would require a much more detailed treatment, for the sake of fluidity, we will simply give introductory aspects that will allow you to pursue the question in your own time.
Concerning the “How to conceive” aspect, this book explains the key points of how an Android application is structured. It presents the various elements that make up the main architecture of the system and explicits how to build an application based on these principles and how to exploit it in the most effective way. Each one of the concepts is explained by a particular Android project containing examples of code.
The reader is encouraged to start by quickly reading the whole book without dwelling too much on each concept so that he might rapidly get an overview of how Android programming works. Then, the reader may refer to specific chapters of interest that he wishes to put to use. Once the reader has assessed the main considerations of any Android application, he may then acquire the “how to” knowledge based on precise examples and use the provided code to build his own projects. Once all the skills have been acquired, this book will remain as a valuable source of information from which he might extract both ready-made code examples and explanations of the keys concepts associated with their use.

Content

This is broken down into four distinct parts.
The first chapter takes a look at the tests strategies that are to be set up. Indeed, one of the great difficulties of Android programming is linked to the great number and diversity of different devices and system versions that an application is expected to comply with.
The second chapter explains how to build the application and how to deploy it. Building and deployment of the application are also to be performed in a particular way when dealing with Android and it is necessary follow certain key steps and understand the process.
Then, a long chapter will explore the ins and outs of managing the application’s life cycle via Maven. This type of management aims at bringing structure, serenity and agility to your project. But, articulating Maven with Android is not a simple affair and depends on certain subtleties that we will take care to explicit. This books aims to present you with the various problems that you will have to face concerning compilation, testing and deployment. For every problem that have encountered we have tried to formulate an associated solution so that you may meet you own deadlines and goals without losing either your time or your nerves.
The final chapter of the book looks at how to set up continuous integration by using Hudson and how to automate testing on a batch of different Android emulators.

 

Who is this book for?

This book is written for the person that is responsible for either a major part or all of an Android project. This means project directors, technical directors, architects, advanced developers…
This book proposes a way to set up an effective development environment and suggests an organized approach. It is capital for those in charge of projects to be fully aware of hundred and one different obstacles that may pop up during the process. Taking a project all the way from original conception to test automation builds on a remote continuous integration server is a long road full of potential pot-holes and pitfalls. This book wishes to provide you with numerous keys and to guide you down this road so as to be able to accomplish and complete projects.
This book is your most complete and detailed guide for this trip.

Table of content

Android, An Enterprise Edition Vision. .................................................................................................... 6
1 Introduction .......................................................................................................................................... 8
1.1 Who is this book for?......................................................................................................................... 9
1.2 Content ............................................................................................................................................. 9
1.3 The structure of the book ................................................................................................................ 10
1.4 Conventions .................................................................................................................................... 10
1.5 Your workspace ............................................................................................................................... 10
An Android project’s life cycle ................................................................................................................ 11
2 Installing a workspace ......................................................................................................................... 11
2.1 Downloads ........................................................................................................................................ 11
2.2 Setting up Eclipse ............................................................................................................................. 12
3 Testing your application ....................................................................................................................... 14
3.1 Testing the devices targeted by the application ................................................................................ 15
3.2 Setting up a test project .................................................................................................................... 16
3.3 Testing an activity ............................................................................................................................. 17
3.4 Testing a ContentProvider ................................................................................................................ 21
3.5 Testing a service .............................................................................................................................. 26
3.6 Monkey and MonkeyRunner ............................................................................................................ 27
3.7 Maven and Hudson automate tests ................................................................................................. 29
4 Adding Jars to your Application .......................................................................................................... 29
5 Building and deploying your Application.............................................................................................. 29
5.1 Signing an application....................................................................................................................... 29
5.2 Deploying an application ................................................................................................................. 31
5.3 Retrieving the key for MapView ...................................................................................................... 32
6 Maven and continuous integration ..................................................................................................... 33
6.1 Maven ............................................................................................................................................. 33
6.2 Bringing together Android and Maven: The Ultimate Android Pom ................................................ 62
6.3 Hudson or test automation ............................................................................................................. 76
Detailed Table of Contents ................................................................................................................... 91
Index .................................................................................................................................................... 96
Bibliography ......................................................................................................................................... 97
7 Books ................................................................................................................................................. 97
8 Online references: .............................................................................................................................. 97

Major Remark

This EBook is the second part of the book "Android, A Complete Course, From Basics to Enterprise Edition". It's dedicated to the Android application's life cycle management :

• Setting up the tests,
• Setting up the builds and the deployments,
• Setting up Maven to manage application's life cycle,
• Setting up continous integration using Hudson.

This book gives you the leads to follow when you are setting up enterprise devlopments of Android applications.