Table of Contents

Chapter 1: Introduction to Android, Mobile Devices, and the Marketplace

Product Comparison

Mobile Development

Android

Cross-Platform Alternatives

Summary

Chapter 2: Introduction to Mono for Android

Before You Begin Developing

Visual Studio Development with Mono for Android

Mono for Android Development with MonoDevelop

Summary

Chapter 3: Understanding Android/Mono for Android Applications

What Is an Android Application?

Binding the Components: The Android Manifest

Summary

Chapter 4: Planning and Building Your Application's User Interface

Guidelines for a Successful Mobile UI

Building an Android UI

Choosing a Control Layout

Designing Your User Interface Controls

Controlling Your Menus

Resolution-Independent UI

Constructing a User Interface: A Phone and Tablet Example

Summary

Chapter 5: Working with Data

Working with SQLite

Upgrading Strategies

Android-Specific Database Options

Working with Remote Data

Retrieving Data Using LINQ and XML

Using Web Services Responsibly

Working with Remote SQL Server Databases

Summary

Chapter 6: Binding Data to Controls

Databinding in Mono for Android

Working with Cursors

Working with Lists

Summary

Chapter 7: Working with the File System and Application Preferences

Working with the File System

Working with Application Preferences

Summary

Chapter 8: Programming with the Device Hardware

Working with Sensors

Responding to Acceleration

Building a Compass

Vibration

Networking Connectivity

Bluetooth Manager

Enabling Voice Recognition in Your App

Getting Turn-by-Turn Directions

Summary

Chapter 9: Using Multimedia — Audio, Video, and the Camera

Android Media Classes

Playing Audio and Video

Recording Audio and Video

Images and Using the Camera

Adding New Media to the Media Store

Speech Recognition

Summary

Chapter 10: Talking to Other Applications and Libraries

Android Application Integration

Application Integration

Integrating with Contacts

Summary

Chapter 11: Developing Background Services and Asynchronous Code

The Life Cycle of a Service

Using Threads for Asynchronous Processing

Communicating with the UI

Notifying the User with Notifications

Summary

Chapter 12: Canvas and Drawables: Building Custom Android Graphics

Working with Graphics in Mono for Android

Using the Canvas Object

The 2D Graphics Library

Using Drawables

Summary

Chapter 13: Working with Location Information

Understanding Location Basics

Selecting a Location Provider

Geocoding

Constructing Proximity Alerts

Using Google Maps

Summary

Chapter 14: Internationalization and Localization

Selecting a Localization Strategy

Updating Language and Regional Settings

Understanding the Mechanics of Android Localization

Supporting Multiple Languages

Localizing Other Resources

Advanced Usage of Strings.xml

Working with Format Conversions

Summary

Chapter 15: Sharing Code between Mono for Android, MonoTouch, and Windows Phone 7

Overview of the Three Platforms

Using Class Libraries to Separate the Code

Assemblies Available on Each Platform

One Class Library to Rule Them All

Putting It All Together: Creating a Cross-Platform Application

Summary

Chapter 16: Preparing and Publishing Your Application to the Market

Preparing Your Application

Publishing Your Application to the Android Market

Summary

Chapter 17: Android Tablets

Examining the Android Tablet Marketplace

Designing a Tablet UI

Using the Action Bar

Partial Screen Control Using Fragments

Summary

Appendix A

Foreword

Introduction

Chapter 1

Introduction to Android, Mobile Devices, and the Marketplace

What's in This Chapter?

A short history of Mono and its relationship to the .NET Framework

How Mono for Android opens the Android platform to .NET developers

Why Mono for Android is so attractive to developers

The history of Android and its mind share

Exploring cross-platform alternatives

The past several years have seen an amazing growth in the use of smartphones. USA Today recently reported on how smartphones have become an indispensable part of people's lives. With growth and popularity comes competition, and, unlike desktop computers, no single vendor or platform dominates the mobile device marketplace; devices based on Symbian, Research in Motion (Blackberry), Windows Mobile, Android, and other platforms are available. In addition, devices may run the same operating system and be presented to the user in separate form factors. This fracture in the marketplace is problematic for developers: How can they take a development framework or tool that they already know and use that knowledge in a device that has a large and growing market share?

This chapter looks at how the largest segment of developers (.NET/C# developers) can target the smartphone that has the highest mind share (Android). It also looks at how the smartphone is growing faster in market share than any other device.

Product Comparison

This section takes a quick look at the .NET Framework, Mono, and Mono for Android. These products have allowed the largest segment of developers to target the Android family of mobile devices—the fastest-growing mobile platform currently on the market.

The .NET Framework

Over the past decade, the popularity of the .NET Framework has grown. In the late 1990s, Microsoft began working on the .NET Framework. The first version shipped in 2002. Microsoft recently introduced .NET Framework 4. The .NET Framework comes in various versions, including 32-bit, 64-bit, a version for the Xbox gaming platform, and a version for Microsoft's mobile devices called the Compact Framework (CF). Here are a few key facts about the .NET Framework to keep in mind as you begin to look at the Mono framework:

Microsoft released a development tool, Visual Studio .NET, with this framework. This tool is the integrated development environment for .NET.

This framework is based on a virtual machine that executes software written for the framework. This virtual-machine environment is called the Common Language Runtime (CLR), and it is responsible for security, memory management, program execution, and exception handling.

Applications written in the .NET Framework are initially compiled from source code, such as Visual Basic or C#, to an intermediate language, called MSIL. The initial compilation is performed by calling the language-specific command-line compiler, Visual Studio, or some other build tool. A second compilation is typically performed when an application is executed. This second compilation takes the intermediate language and compiles it into executable code that can be run on the operating system. This second compilation is called just-in-time (JIT) compilation.

This framework is language-independent, and numerous languages are available for it. In Visual Studio, Microsoft has shipped various languages, including Visual Basic, F#, C++, and C#.

This framework has a series of libraries that provide consistent functionality across the various languages. These libraries are called the base class libraries.

Microsoft has submitted various parts of the .NET Framework to various standards organizations, including those for the C# language, the Common Language Infrastructure, Common Type System (CTS), Common Language Specification (CLS), and Virtual Execution System (VES).

This framework has the largest number of developers of any development framework. As a result, more developers are familiar with the .NET Framework than any other development framework.

A disadvantage of the .NET Framework is that it is unavailable for non-Microsoft platforms.

The significance of all this is that Microsoft has created a standards-based environment for the .NET Framework. Though most developers working on the Microsoft platform are not worried about the standards compliance of the .NET Framework, the significance of this aspect of the .NET Framework cannot be understated. By defining these standards and submitting these standards to compliance committees, Microsoft has created a group of developers that can integrate at fairly low levels into the .NET Framework. In this environment, Miguel de Icaza had a vision and stepped up to create the Mono framework discussed next.

Mono

Mono is an open source project that provides a C# compiler and CLR on non-Windows operating systems. Mono is currently licensed under GPL version 2, LGPL version 2, the MIT, and dual licenses. Mono runs on Mac, Linux, BSD, and other operating systems. Along with the C# compiler, additional languages run on Mono, including F#, Java, Scala, Basic, and others.

Mono, the brainchild of Miguel de Icaza, was officially announced in 2001. Version 1.0 shipped in 2004, and currently Mono is at version 2.10, though it is continually being upgraded and will most likely be at a later version by the time you read this. Currently, Mono has parity with many of the features in .NET 4. Mono continues to be directly led by de Icaza. Recently, the stewardship of Mono has passed to Xamarin. Xamarin leads the direction of Mono. Mono started as an open source implementation of a C# compiler. It grew from this initial design into the current open source implementation of .NET. It is now Xamarin's responsibility to nurture Mono. Xamarin is responsible for the development of Mono for Android, MonoTouch, and the software that makes these products work for the developer. Given that Xamarin is laser-focused on Mono in the mobile area, I think these products are in good hands.

As much as there is a desire to match the .NET Framework's features, this is not possible because Microsoft has more resources and a head start on the development of those features. At the same time, the Mono project has parity with a large number of .NET Framework features. The best that Xamarin will most likely accomplish is to be shortly behind the .NET Framework for most of the APIs that are possible.

Along with Mono is the open source IDE called MonoDevelop, which started as a port of the SharpDevelop IDE. MonoDevelop began as a project to allow for Mono development on Linux, but with the release of MonoDevelop 2.2, the ability to develop with Mono expanded to the Mac, Windows, and several other non-Linux UNIX platforms.

Although the .NET Framework is very popular, two issues make it unsuitable for running on Android:

At some level Google and Microsoft are competitors and are probably not too excited to work together. Microsoft has had Windows Mobile devices for years, which compete directly with Google's Android operating system.

The .NET Framework fundamentally is a major competitor for the Java Virtual Machine that is at the heart of an Android device. This Java VM is called Dalvik. The .NET Framework and Java have been competitors since the initial announcements of the .NET Framework.

A disadvantage of .NET/Mono and Android is that .NET/Mono developers cannot take their .NET/Mono/C# knowledge and apply it to the Android platform. Figure 1.1 shows this concept. .NET/Mono developers can't target Android because they're two separate entities.

Figure 1.1

In 2009, the Mono team announced and shipped MonoTouch, the forerunner to Mono for Android. MonoTouch allows developers familiar with C# to target the Apple iPhone. Based on the experience of building MonoTouch, the Mono team learned how to effectively and efficiently build a C#/Mono layer that sits on top of the device's native application programming interface (API).

Mono for Android

In April 2010, Apple introduced fear, uncertainty, and doubt into the mobile development marketplace by making changes to its software development kit (SDK) licensing. This change caused many developers to question developing for the iPhone and iOS. At that point in time, the Mono team had been experimenting with creating a Mono product for Android similar to its MonoTouch product. Due to Apple's SDK changes, the Mono team announced the Mono for Android product and put significant resources behind it. Mono for Android shipped in the spring of 2011. While Apple eventually rescinded their SDK issues, the 5 months during which MonoTouch sat in limbo allowed the Mono team to put significant resources into developing Mono for Android. The result of this is that Mono for Android is further along than it would have been if Apple had not put MonoTouch into limbo for all those months in 2010.

Mono for Android allows .NET developers to create native applications that run on Android. These applications look and feel like native Java applications running on Dalvik. With Mono for Android, applications are compiled into executable code that runs on Android devices. The significance of this should not be understated: .NET/Mono developers can target Android through Mono for Android, as illustrated in Figure 1.2

Figure 1.2

How does Mono for Android accomplish this? Does it somehow allow Windows Forms applications to be translated or recompiled and deployed on Android? Mono for Android provides a .NET layer over the native programming layer present on the Android OS. Developers targeting Dalvik would write applications in Java. Mono for Android does not provide a mechanism to cross-compile Windows Forms applications, but it allows developers to build applications that run natively on Android.

Overall, the API exposed by Mono for Android is a combination of the .NET 4 Framework's core features, Silverlight APIs, and the native Dalvik Java VM. Mono for Android provides a bridge (interop) layer between Android's native APIs and the APIs that .NET and C# developers are accustomed to.

Mono for Android Components

Mono for Android is made up of a set of assemblies, namespaces, and classes that are optimized for mobile platforms. This code is a combination of the .NET 4, Silverlight, and Windows Phone profiles, as well as code that allows a developer to take advantage of the Android platform.

Namespaces and Classes

Mono for Android provides a rich set of namespaces and classes to support building applications for the iPhone. Here are some of the most popular assemblies and the functionality that they provide:

Mono.Android.dll: This assembly provides the C# bindings to the Android APIs. This includes namespaces that support the Android.* namespaces.

System.dll: This assembly provides much of the .NET Framework functionality for Mono for Android.

Mono.data.Sqlite.dll: This assembly is an ADO.NET provider for the native SQLite database.

Mono.Data.Tds.dll: This assembly provides the support for the TDS protocol, which is used to connect to SQL Server.

OpenTK.dll: This assembly has support for OpenGL.

System.Json.dll: This assembly provides support for using JSON.

System.ServiceModel.dll: This assembly provides support for WCF.

System.Xml.dll: This assembly provides support for XML.

System.Xml.Linq.dll: This assembly provides support for LINQ to XML.

Within these assemblies, Mono for Android also provides namespaces that may be important to you. These are:

Android: The Android.* namespace provides resources, classes, and application permission support.

Android.Bluetooth: This namespace provides support for Bluetooth.

Android.Database: This namespace provides support for the SQLite database on the device.

Android.Graphics: This namespace provides support for graphic display.

Android.Hardware: This namespace provides support for hardware on an Android device such as the camera.

Android.Locations: This namespace provides the necessary support for location.

Android.Net: This namespace provides support for networking, including support for Voice over IP (VoIP) and WiFi.

These namespaces are a small subset of what is available inside of Mono for Android and are fairly self-explanatory in their functionality. Also, these namespaces are specific to Android. Code that is written using these namespaces will only run on Android-based devices.

Development Tools

No matter what type of project you are building, development tools are an integral part of creating an application. Long gone are the days of a bunch of files, a character-based editor, command-line output for debugging, and a make file as the only way to build an application.

Developers who work in the .NET Framework are familiar with Visual Studio. Visual Studio is Microsoft's development tool. It includes support for solutions, projects, a visual design surface, databases, and numerous other features.

Similarly, Mono has its own development tool; MonoDevelop is a free IDE used for developing with Mono and is an early branch of the SharpDevelop IDE. Originally, MonoDevelop ran only on Linux, but with version 2.2, MonoDevelop began running on the Mac and Windows. MonoDevelop lets you create and manage numerous projects as well as debug and deploy to the simulator and devices for testing.

Thankfully, the Mono team has produced Mono for Android, which will work across Visual Studio and MonoDevelop, as well as a plug-in for operating systems other than Windows. This facilitates writing code with Mono for Android across Visual Studio, MonoDevelop on the Mac, and MonoDevelop on Windows. Developers are free to use whichever of these development IDEs they prefer. At this point in time, I have personally found that Windows and the Mac each have their own advantages, including:

Debugging on Windows is where most developers starting with Mono for Android will probably start.

Debugging on the Mac seems to work very well in the Android emulator.

Mobile Development

Developers need to keep a few key ideas in mind when building applications on Android with Mono for Android:

The Android simulator is good for initial testing; however, it is not necessarily accurate for all testing. Just because something works in the simulator doesn't mean it will run on all Android devices in the same way. Final testing should be completed on different versions of Android devices.

As of the Android SDK available for the writing of this book, testing on a device is typically more accurate for advanced features. For basic development, the emulator is easier to work with. Thanks to snapshots, it's typically quicker to work with as well.

.NET executables are fairly small because they can use a shared copy of the framework. Mono for Android can have applications deployed two different ways. The most common way is to have the application and Mono for Android bound together. A second way is for the applications to share the Mono framework. This makes application executables small, but it also means that a copy of the Mono framework for Mono for Android must be installed on the device.

At the time of this writing, it is suggested that the application be bound with the Mono for Android runtime. This is currently what is done when a “Release” build of the application is done..

It is important to be a good citizen on a device. Developers will need to continually think about how to implement features that are good citizens.

Getting Around Support Issues

Although Mono for Android is a commercially licensed product, it is still under continual development, so it might not support a specific namespace or assembly. You have two options in this situation:

1. Wait on the implementation of that assembly from the Mono for Android product.

2. Pull the necessary code or reference the necessary assembly in your project. This is fairly common if the application needs to use code within the System.Web.* namespaces. For example, imagine an application that needs to call a REST-based web service and needs to encode data before it is sent. System.Web.HttpUtility.HtmlEncode() should be called. Unfortunately, the System.Web namespace is not part of Mono for Android by default. You must add this namespace by referencing the System.Web assembly in your application.

Design Issues

In addition to the technical issues of building an application for Android, here are some design issues developers should be aware of:

Don't design an application for a desktop environment and think that it can be scaled down to Android or any mobile device. Android does not have the display, hardware, or storage of a desktop computer. Android and mobile device applications are good for simple, limited-purpose functions, but they should not be expected to do everything that a desktop application does.

The Android simulator is a fine tool, but don't limit your testing to it. A simulator is just that. A keyboard and mouse are associated with the Android simulator since it is primarily running on the desktop. Also, understand that the simulator is ultimately using the CPUs of the development system. While the CPU of a device is fine for the device, it really isn't comparable in terms of performance with a desktop. The desktop has a high click speed, more memory, and typically has higher speed and higher quality Internet bandwidth. To really test a complicated design, you must test the application from Android on a mobile device while running on a mobile network.

When testing on a device, though WiFi is a mobile network, the WiFi in your office or home is typically of a higher quality than a mobile provider's network. Typically, WiFi will have lower latency and higher bandwidth than a 3G (or worse) connection. Applications must be tested in a mobile scenario. Get a coworker to drive you around to test an application.

Android

There's no doubt that Android devices took off in the first half of 2010. Although the Android phone was not the first graphical phone, it was the first product that provided its software free to phone device manufacturers, made it easy to use, and provided an easy-to-use marketplace to purchase applications.

History of Android

In July 2005 Google purchased a small company called Android, Inc., which was involved in mobile software. With this purchase, Google began heading in the direction of mobile devices. Rumors regarding Google's entry into mobile devices began to ramp up in December 2006. In the fall of 2007, the Open Handset Alliance (OHA) was formed, with the goal of creating a set of standards for mobile devices. The alliance has at its core a mobile device architecture based on the Linux Kernel version 2.6 (and later), along with an SDK that can be used to build native Android applications. In the fall of 2008, the first Android phone shipped.

The initial shipment of Android was not well received in the marketplace. It was criticized significantly by the media and by the first users of the platform. However, Android had several big advantages over competing platforms that were not evident at the time. Android is an open platform. As such, manufacturers are competing against other mobile device manufacturers as well as against other members of the Open Handset Alliance. This means the pace of innovation at the hardware level is significant, and the Android platform shows it compared to other platforms. Android devices are not limited to one manufacturer or one telecommunications carrier either. As such, telecommunications carriers must compete with each other. These two factors and others have led to a significant amount of innovation and advancement in the Android and mobile device marketplaces.

After some initial teething pains, the Android SDK has grown up. (You can find a discussion of the tools available in the Android SDK—and pertinent to Mono for Android developers—later in this chapter.) After numerous beta releases in 2007 and 2008, the 1.0 release of the SDK occurred in September 2008. Since that time, many additional SDK versions have shipped.

In the fall of 2009, OHA introduced the Android 2.0 (Eclair) operating system. This was a watershed event for Android. Along with the shipment of Android 2.0, Motorola released the Droid phone, and Verizon began significantly marketing the product. From that point Android has quickly grown in the marketplace.

In 2010, OHA shipped Android 2.1. In addition, HTC, Motorola, and others produced a family of high-end devices. The shipment of these items further accelerated Android's growth and mind share. At the same time, a number of manufacturers introduced tablet devices based on Android.

In early 2011, devices based on Android 3.0 (a.k.a. Honeycomb) shipped. This version of Android is optimized for the tablet environment. Unfortunately, this version of Android has not been well received in the marketplace.

In late 2011, Google announced and shipped Android 4.0 (a.k.a. Ice Cream Sandwich). Ice Cream Sandwich is the version of Android that unifies the programming APIs for Android phones and tablets.

Growth has been a hallmark of the Android platform. Since its first availability in 2008, Android shipments have grown significantly. Gartner Group is predicting that Android will see tremendous growth at least through 2015. Considering that Android had so few devices in the marketplace in 2008, this growth is mind-boggling.

Writing Web-Based Applications for Android

Writing a web-based application for Android is fairly simple. The WebKit web browser is a great tool; it does an excellent job of scaling web-based applications to run on an Android-sized screen. It also does well at running applications that are highly dependent on JavaScript. Upgrading an Android web-based application is also a simple matter of deploying a new version of the application to a web server. Many applications have taken this approach. And although HTML5 has a number of great features, a web-based environment has some inherent limitations.

Unfortunately, web applications are not suitable for all applications. Applications that require some background processing and access to local resources must work when a network connection is unavailable, and some other application types don't work well in this model.

So, the question becomes how you write a native application that fits into Android.

Writing Native Applications for Android

These native applications are a great improvement over web-based applications, which are limited in what they can do on a device. Fundamentally, web-based applications have to be loaded over the web and cannot access all device features. Native applications tend to have more support for device features such as the accelerometer, file system, camera, cross-domain web services, and other features that are not available in HTML and JavaScript. In addition, native applications do not depend on the wireless network to be loaded, whereas a web application is dependent on the wireless network for nearly everything.

Android Development Issues

Developers must consider several issues when running applications on the device:

There are a tremendous number of form factors, screen sizes, and devices. An application may look great on an HTC device but not on a slightly older Droid device. Developers must take device differences into account. For example, while Twitter for Android runs on an HTC Android device as shown in Figure 1.3, it definitely has a different look than when it runs in a Motorola Xoom Android device, as shown in Figure 1.4 (note that user pictures have been removed from these figures to protect privacy).

Developers must take into account the various versions of the Android operating system. Some users may be running Android 2.0, and others may be running 3.0.

Developers must be realistic about the sales numbers of applications delivered through the Android Market. Even though Android has experienced a phenomenal growth rate, this excitement must be tempered, because the Android Market has a higher percentage of free applications compared to the Apple App Store. Your sales numbers may be more for an Android version of an application, but average sales prices for applications on Android are less than average sales prices for iPhone devices.

Figure 1.3

Figure 1.4

Developers need to be aware of these issues. They may require you to spend more time in development when building applications for Android.

Android SDK Tools

The Android SDK contains a number of tools, including a set of libraries for the Android platform, a debugger, a simulator, and various pieces of documentation. The following tools are the most important to the Mono for Android developer:

Libraries: Mono for Android is a layer over the top of the existing Dalvik-based APIs. So, learning the API calls of the Dalvik libraries will help you learn Mono for Android.

Simulator: The simulator is the first tool that developers use to test their applications. It allows them to create various simulated versions of Android, screen resolutions, memory, and other hardware factors.

One thing that developers will find missing, at least in the initial versions of Mono for Android, is a design surface. When the Mono team shipped MonoTouch, it used the Interface Builder SDK tool. Unfortunately, the Android SDK has no design surface. Further, due to time constraints, the initial shipments of Mono for Android also don't include a design surface.

Fortunately, all is not lost for developers. There are currently two ways to create a user interface for Mono for Android:

1. Edit the user interface XML by hand. Obviously, this method is error-prone.

2. Design the user interface through third-party tools such as DroidDraw. DroidDraw is a standalone design surface for building an Android user interface. DroidDraw can be seen in Figure 1.5.

Figure 1.5

Android Development Costs

The SDK is a free download. However, to release software for Android, a developer must join the Android Market Development Program. The current cost to join in the United States is $25 a year. The cost of joining varies from country to country. The ability to distribute applications to devices depends on having the necessary development certificates. These are available through the Android Developer site after you join the Android Development Program. Certificates are discussed more in Chapter 16.

Cross-Platform Alternatives

The choice of using a cross-platform development tool, such as Mono for Android or MonoTouch, is not one to be made lightly. Even though Mono for Android offers a superior combination of native development and integration with the .NET stack and leverages the power of Visual Studio, it is important to not only be aware of the differences between native and non-native development tools, but also understand the differences between the various cross-platform options.

Other Cross-Platform Tools

In addition to Mono for Android, there are several other options out there that can be used to develop mobile applications that can target Android as well as other platforms. Here are a few examples of other cross-platform mobile development tools:

PhoneGap is a cross-platform mobile development tool that focuses on using standards-based web technologies, including HTML5, jQuery Mobile, and so on. Like Mono for Android, PhoneGap uses a common technology to allow developers to not only write applications for their target mobile devices but also to directly access some of the native features of the device, such as the compass, the camera, or the file system.

Appcelerator Titanium is another cross-platform tool that allows a developer to write applications using HTML, JavaScript, and their own library of APIs that grant access to several of the mobile device's features. Much like Mono for Android, Titanium can be compiled into the native language, meaning that you can present the same kind of experience that other native applications may offer.

RhoMobile Rhodes is a Ruby-based framework that allows you to build cross-platform applications. This tool allows you to compile into native applications that can access many of the device's features.

These tools are among the most popular of the many other cross-platform tools in the market today. Because needing to target multiple mobile platforms with as little effort as possible is a common problem, you have many different solutions to consider.

Considerations for Selecting a Cross-Platform Tool

When selecting a cross-platform tool, you have to consider many different things. In some cases, some options may provide too simple a solution and maintenance/features could quickly become unwieldy or even impossible. Other tools could offer many, many native features, but in the process, introduce additional complexity beyond what a native approach might have offered. Because of this, making the right tool selection is critical. The following sections discuss a few things developers should ask themselves about the tool before making their selection.

How Does the Tool Allow You to Author Your Application?

As far as cross-platform tools go, they tend to take one of two approaches to allow developers to write their applications. The first approach is to utilize a mobile device's natural support for web browsing, whereas the second approach is to develop the means to translate or compile a common language, such as C# or JavaScript, into the native language, such as Java for Android/Dalvik or Objective-C for iOS.

Utilizing a mobile device's natural affinity with web browsing allows developers to work primarily with HTML and JavaScript, which makes development approachable for a very large subset of potential mobile developers. In addition, there are a plethora of development tools and environments that make the development process fluid and painless. A great example of this approach would be PhoneGap.

Unfortunately, this approach tends to have a couple of flaws. For starters, this approach results in a web application with native features rather than a full, native application. Although web applications have come a very long way in the past few years, they are quite different than native applications and have their own special foibles. In addition, users tend to appreciate the experience of a native application over that of a web application. The second flaw with this approach is that support of native features can be limited and, in some cases, impossible. Generally, access to native features is achieved through a custom JavaScript API.

The second approach, translating or compiling from a common language to the native language, allows the users to harness the native speed and features of the application while also writing in another, more accessible language. The large benefit to this approach is that you end up with the look and feel of a native application as well as native performance speeds. Mono for Android is a great example of this approach.

The flaws of this approach are that these solutions tend to require a slightly more advanced skill set. Whereas the web browser–based approach usually requires a basic understanding of HTML and browser page request life cycles, the compiled approach requires an understanding of the underlying architecture and design paradigms of the mobile platform. For instance, a Mono for Android developer needs to have at least a basic understanding of Android before they can begin writing an application. Finally, some of the cross-platform tools may require some platform-specific code to fully compliment the solution—particularly when it comes to handling UI logic.

What Device Features Does the Tool Support?

When considering the tool to select, you need to have a good idea of what features are most important for you as an application developer. If you are writing a simple application that will display some kind of data to the user, you probably have little concern over whether or not your solution supports the accelerometer. However, if you are developing a simple game, this could be a make-or-break feature. For the most part, every tool provider expressly lists the limitations of their product.

When working with a cross-platform tool such as Mono for Android, a developer is often trading features or flexibility for simplicity and familiarity. Before you choose a cross-platform tool, be sure to have a general concept of what you are trying to create and ensure that the tool supports the features that you desire. Thankfully, Mono for Android has very few limitations and has them clearly defined at http://docs.xamarin.com/android/about/limitations.

What Platforms Does the Tool Support?

There are a wide variety of cross-platform tools out there, and each of them supports a different number of platforms that range from most mobile device OSs to even the various desktop OSs. When selecting your tool, consider where you plan to deploy your application as well as whether the deployed application's design and usage patterns would fit with the target platform.

For instance, Appcelerator Titanium boasts the ability to deploy not only to some of the major mobile platforms but also to Windows, Linux, and Mac. On the other hand, Rhodes focuses on supporting the major mobile platforms—including Windows Phone 7, RIM, and Windows Mobile.

Although we have discussed the feature support consideration, make sure that your needed feature is supported across all the platforms that you want to deploy to. For instance, if you have an application that is dependent upon the compass feature of the device and you want to target Android and WebOS, PhoneGap would not be the platform for you.

What Skill Sets Does the Tool Require?

Each approach offers some kind of common language to begin application development. Whether that language is HTML or C#, it is important to ensure that you have the skills in house to cover the development needs of the tool. In addition to this, some solutions require you to have intimate knowledge of the mobile platform's framework or, at times, intimate knowledge of the tool's custom APIs.

With the HTML approach, a strong understanding of HTML and JavaScript can take a developer a long way. On the other hand, the translation/compilation approach often requires a basic understanding of the target platform framework— especially in regards to developing the user interface.

What Tools Exist to Support Development?

One of the most important considerations of your cross-platform tool is what kind of development tools exist to support the coding process. Development time for a solution can be vastly different when using a specialty, proprietary tool versus a full-featured development environment, such as Visual Studio.

How Active Are the Development Community and Support Channels?

When considering the cross-platform tool of your choice, take some time to familiarize yourself with the development community. Are there active mailing lists or forums? How frequently do developers respond to users' requests? How often are other developers answering each other's issues? Solutions with poor developer support or a stagnant community are unhealthy signs.

What Are the Successful Application Deployments for This Tool?

Most cross-platform tool vendors will quickly list any application success stories as a way to brag about their solution. Take some time to download these applications and see how they interact and perform on your target mobile devices. Given the chance, take a moment to communicate with the application developer to ask them about their development experience using this toolset.

If you are reading this book, you are clearly interested in Mono for Android as a solution. With that in mind, it may seem somewhat strange to discuss alternative approaches to cross-platform development. The reason for this approach is to help you make an informed decision about a development tool rather than an incidental one. By taking the time to understand the strengths and weaknesses of other solutions, you will, hopefully, be able to make the best choice for your application. Mono for Android (and Mono Touch) has many strong features that enable it to accommodate just about any development scenario.

To answer our own previous question, there are very clear reasons why Mono for Android stands out as an excellent cross-platform development tool:

Mono for Android gives a developer access to the tooling and developer stack as provided by Microsoft. Considering the kind of investment that Microsoft puts into Visual Studio, this is a huge benefit to the developer. You can continue to work in Visual Studio and use your existing tools, like ReSharper.

Mono for Android runs natively, providing almost all of the native capabilities. In addition, by supporting mobile platform–specific UI elements, it allows developers to reuse large portions of their code without sacrificing the performance and agility to match user expectations.

Mono for Android has a large, active development community. Mono for Android developers actively work to address any developer concerns or issues.

Summary

This chapter looked at the following items:

A product comparison of the .NET Framework and Mono

Mono for Android, which allows .NET developers to target Android

The Android platform, its licensing, and its operating system

Cross-platform alternatives for developing Android applications

You should now understand which tools are needed to build a native application with .NET/C# for Android. The next chapter explores the specifics of building a Mono for Android application with Visual Studio and MonoDevelop. Chapters 4 and 5 describe how to work with the user controls for user input and how to present data to the user in a standard form factor. Other chapters in the book discuss specific parts of Android, such as maps and acceleration.

Chapter 2

Introduction to Mono for Android

What's in This Chapter?

Introduction to Mono and Mono for Android

Configuring the development environment

Mono for Android tools for Visual Studio

Debugging and deploying

What is Mono for Android? This chapter provides the basis for Mono for Android development. It starts with an overview of Mono and then moves to a discussion of Mono for Android, configuring the development stack, and developing and deploying a “Hello Mono for Android” application — first to an emulator and then to your Android-based phone.

Before You Begin Developing

Before getting started with development, you need to learn about a number of items that will help you understand the development environment and the tools that are involved. This section covers what Mono is and how it is implemented. Then it discusses what Mono for Android is, along with its benefits and implementation. Finally, this section discusses the development stack before moving on to development.

What Is Mono?

Mono is an open source project sponsored by Xamarin to create an Ecma standard implementation of the .NET common language infrastructure (CLI), a C# compiler, and an open development stack. The Mono project was started by Ximian in 2001, and version 1.0 was released in 2004.

Mono Implementation Goals

The Mono implementation is currently targeting three goals:

An open source CLI

A C# compiler

An open development stack

The CLI provides the runtime environment for languages that have been compiled to the Common Intermediate Language (CIL). The C# compiler is responsible for compiling C# code to CIL for execution on the runtime. The open development stack facilitates development and includes an IDE in MonoDevelop and several libraries beyond the core libraries to provide open cross-platform development. These libraries include GTK# for graphical user interface development, POSIX libraries for UNIX/Linux compatibility, Gecko libraries, database connectivity libraries, and XML schema language support via RELAX NG.

Mono Standards

Mono adheres to the Ecma Standard. Ecma International was formed in 1961 to support the standardization of information and communication technology. In 2005, Ecma approved version 3 of C# and CLI as updates to Ecma 334 and 335. Currently, a working draft of the Ecma 335 CLI is in progress.

The Mono C# compiler is currently feature-complete per the Ecma standards for C# versions 1, 2, and 3 in version 2.6. Version 2.6 also includes a preview of C# 4, with a feature-complete version of C# 4 available in the trunk of version 2.8.

What Is Mono for Android?

Mono for Android is a runtime and development stack that allows .NET developers to leverage their knowledge of Visual Studio and C# to develop applications for Android-based devices.

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!

Lesen Sie weiter in der vollständigen Ausgabe!