This is the first post in a multi-part series on Android development for .NET developers.  Throughout the series, we’ll explore how to build applications for the Android platform and approach concepts in a way that’s familiar to .NET development.  This first post is an introduction to the Android SDK and the Eclipse IDE along with a high-level overview of Android applications.

PreRequisites

• Java Development Kit (JDK) 6 – self-explanatory; the Java runtime and development libraries.
• Eclipse – an IDE (integrated development environment) for Java and other languages.   If you don’t have it installed, grab the Eclipse IDE for Java Developers version, which will suit the needs of this tutorial.  The Windows download doesn’t contain an installer, so extract the ZIP in an accessible location, such as C:\eclipse.
• Android Software Development Kit (SDK) – The heart of Android development.  This provides all of the necessary tools and libraries required to build applications for the Android platform.  Extract it to an accessible location on your hard drive and run the setup executable, which will download and install a set of components.
• Android Development Tools (ADT) Eclipse Plugin – This plugin adds Android-specific development tools and project templates to Eclipse.  Instead of a separate download, it installs within Eclipse – you can follow the instructions here to get it installed.

Configuring the Android SDK and Creating Your First Project

Okay, take a deep breath – we’re ready to get started.  Launch Eclipse by navigating to your extracted folder and double-click on Eclipse.exe.

Before we jump into a project, we’ll need to configure the Android SDK preferences.  Select “Window” from the menu bar and choose “Preferences.”  Choose “Android” from the list on the left.  In the “SDK Location” field, navigate to the folder where you unzipped and installed the SDK and hit “Apply.”  You should see the list of SDK Targets get populated.  These targets are a list of Android platform versions that you can build on.  Unlike the iPhone, which has one standard set of hardware, the Android platform is open to various hardware manufacturers which use different versions that support different sets of functionality.  For example, the HTC Droid Incredible runs version 2.1, but the T-Mobile G1 only supports version 1.6.  We’ll address these differences later.  For now, just be aware that there are various versions of the platform and click “OK” to close the window.

Next, we’ll create our Android project.  The Android SDK comes with over twenty sample applications, so we’ll create a project using one of those to get acquainted with everything.  From the menu bar, choose “File” -> “New” -> “Project.”  The pop-up window that appears is similar to the “Create Project” wizard in Visual Studio – you’ll see a list of project templates that control how your project is initially set up.  In VS, you could select things like “ASP.NET Web Application” which would automatically configure your web server and add the Default.aspx and web.config files to the project.  Here, we’ll drill-down into the “Android” group and select “Android Project” which will add all of the necessary references to the Android SDK, among other things.  Once “Android Project” is selected, click “Next.”

Now we will set up the basic details of our project.  Under the “Contents” group, choose “Create project from existing sample.”  Then, from the “Build Target” list, select the “Android 2.0″ checkbox.   The “Samples” drop-down will populate with all of the sample applications that come with the Android SDK.  Choose “Snake,” which is a port of the classic game.  When you select it, the “Project Name” and “Properties” fields will automatically populate.  Click “Finish” and your project will be created.

Now that our project is created, let’s explore the Eclipse IDE.

Getting Familiar with Eclipse

When you create a project in Visual Studio, by default, the files will get put in the My Documents/Visual Studio 2010/Projects folder.  Similarly, Eclipse projects will get created in your “workspace.” The location of this gets specified when Eclipse is launched.  I keep my workspace in my User directory, at C:\Users\nathan.dudek\workspace.  However, since we chose an existing sample project, you won’t find the Snake project in your workspace on the filesystem.  Instead, it uses the existing files in the Android SDK’s “samples” directory.  In this case, you’ll find everything at the “<path to android sdk>\platforms\android-5\samples\Snake”.

In Visual Studio, we’re used to Project and Solution files, such as “Company.Application.proj.”  Eclipse also uses project files, but in every case, the filename is “.project.”  The context of the particular project is taken from the directory that it resides in instead of a descriptive filename.  Take a peek at the contents of this .project file in a text editor and you’ll notice it’s very similar to a .NET project file – XML describing various properties of the project.

We’re also used to the concept of “References” in Visual Studio – pointers to various assemblies and libraries that are utilized in the application.  Eclipse (actually, Java) handles this with a “Class Path”.  All references to outside libraries, such as JAR files (similar to DLLs), need to be included in this class path.  Eclipses stores these in the “.classpath” file alongside the .project file.

Let’s take a look at the Eclipse UI.  Eclipse is built on around an extremely powerful, pluggable architecture, so it can seem complex and confusing at first.  But, after navigating around a bit, you’ll find many tools that appear similar to the ones you’re used to in Visual Studio.  After all, the tools you need to build and debug an application, regardless of platform or language, are generally the same.

• Package Explorer – Similar to the Solution Explorer in Visual Studio.  Let’s you navigate through the various files in your project.
• Editor Window – tabbed, colored-syntax editor window.
• Problems – Shows you build errors and warnings, similar to the Error List in Visual Studio.
• Console – Shows you build messages and runtime output, similar to the Output window in Visual Studio.
• Toolbar – You’ll see the buttons to debug, run, save, open, etc.

One other quick note about Eclipse before we jump into the Android application itself – by default, it will build the application automatically as you edit it.  It’s a handy feature to find problems as you create them!  I liken it to personalized continuous integration – immediate feedback that you broke the build.

Take a few moments to get familiar with the IDE. Ready to dive into Android code? Let’s go!

Note: Several readers have sent me a note saying that an error appears in the “Problems” window when the project is opened, stating that “Project ‘Snake’ is missing a required source folder: ‘gen’.” To fix this error, expand the “Snake” project in the “Package Explorer” window, then expand the “gen” folder along with the “com.example.andorid.snake” item below it.  Delete the file R.java by right-clicking on it and choosing “Delete.”  The file will immediately be regenerated and the error will disappear.  I haven’t discovered the cause of this yet; I don’t know if it’s a problem with Eclipse or the Android samples, but if I find out more I will update this post.

Exploring the Components of an Android Application

There are five key components that make up Android applications:

• Activity – Activities represent your application’s user interface layer.  Each Activity represents a single action that a user can interface with.  It could be related to a Form.
• Service – Services represent background tasks.
• Broadcast Receiver – Broadcast Receivers react to announcements, similar to events.  An example of system-level announcement could be that the battery is low.  Applications (including your own) can also generate their own announcements.
• Content Provider – Content Providers expose datasets from your application to other applications.  If our Snake sample application wanted to allow other applications to access the high scores, it could expose them in a Content Provider.
• Intent – Intents are messages.  You can use intents to send messages to a specific Activity or Service, or send it to the entire system.

Each of these components are represented by Java classes – Activity, Service, BroadcastReceiver, ContentProvider, and Intent, respectively.  The classes that make up your application end up being subclasses of these base classes.  Java uses the “extends” keyword to perform inheritance.  So,

public class Snake extends Activity { ... }

in Java is basically the equivalent of

public class Snake : Activity { ... } 

in C#.

You can read about these components in detail in the Android Developer Documentation at http://developer.android.com/guide/topics/fundamentals.html

Every Android application also has a “manifest” file which This is stored in the file AndroidManifest.xml, included with the Snake sample source.  The main purpose is to inform Android what components make up the application.

Our simple Snake sample application will only deal with a single Activity and none of the other components mentioned above.  Our Activity represents the Snake game that the user can play.  Let’s take a look at the source code by opening up the Snake.java file.  You can find it in the “Package Explorer” window by drilling down to Snake -> src -> com.example.android.snake -> Snake.java.

You’ll notice the file is only 83 lines long.  That’s because this file simply represents the Android Activity – the actual Snake game logic is contained in the SnakeView.java file.  Here are the key things to note about Snake.java:

1. It’s a subclass of Activity.

   public class Snake extends Activity

2. Three methods from the Activity base class are overridden, as noted from the @Override keyword (same as the override keyword in C#):

   public void onCreate(Bundle savedInstanceState)

   protected void onPause()

   protected void onSaveInstanceState(Bundle outState)

   These three overrides handle the events that the method names state – when the activity is created, when the game is paused, and when the application state is saved.

3. This Snake class relies heavily on the SnakeView class, which you can also find in the src folder.  SnakeView is a subclass of another very important Android class – View.  Views are used by Activities to draw things to the screen and handle user interaction.  Since we’re just trying to demonstrate the Android specific components of this application, just understand that SnakeView handles all of the details of user keystrokes, drawing and animating the snake to the screen, etc.

Let’s run the application and see how it launches.

Launching the Application in the Simulator

From the menu bar, click Run ->Run.  You’ll get a message stating “No compatible targets were found.  Do you wish to add a new Android Virtual Device?”  Click yes to set up the Android simulator.

Since we chose Android 2.0 as our platform during the project setup, we’ll create an Android 2.0 virtual device.  Enter a device name such as “Android2.0″ and choose “Android 2.0 – API Level 5″ from the Target drop-down list.  Then click the “Create AVD” button to complete the setup.

Click Run -> Run again to launch your application in the simulator.  The first run may take several minutes to load the virtual device, so don’t be alarmed if your application doesn’t launch immediately.  Once it finishes loading, your Snake game will appear on the screen.

You can use the on-screen buttons to interact with the simulator, or you can use the buttons on your physical keyboard.  You can also interact with the rest of the Android platform by using the Home, Menu, Back, and Search buttons.

Next Steps

It’s worth exploring the samples provided with the Android SDK.  They cover many aspects of the available functionality, such as voice recognition, gaming, BlueTooth, gestures, and graphics.  In the next post, we’ll create an Android project from the ground up and create our first basic application.  In the meantime, dive deeper into the Snake source code and its SnakeView.java file if you want to see how the game logic and drawing engine works.  Also, take the time to get familiar with the Eclipse IDE.  After a little playing around, you’ll find it’s a pretty comfortable (and powerful) IDE.

My five-year-old developer rig has had a great run, but lately, it just hasn’t been able to keep up with my needs – not to mention a lot of random artifacts and lines on the monitors, indicating the impending death of my video card.  So, I set out to build my own ultimate developer rig, but on a  lower budget of $1100.

This $1100 budget took into consideration the reuse of my existing chassis, data hard drive, DVD-RW drive, and dual monitors.  So, if you’re setting out to build one from the ground up with similar components, a budget of $1400 is probably more realistic.

Somewhat similar to Hanselman’s priorities, the requirements for my rig were as follows:

1. Fast.  When I launch an app, I want it to display immediately.  When I compile, I want fast build times.  When I power it on, I want Windows to boot fast.  When I click on something, I want the action to register immediately.
2. Multitasking.  Since I often run a ton of applications at once, some of which can be memory hogs, I need it to remain fast and performant even with tons of windows open.  If I can have multiple instances of VS2010, Photoshop, Eclipse, VirtualBox, Tweetdeck, iTunes, Firefox, and Word open simultaneously without losing much performance, it’s a win.
3. Quiet.  I like to work in a quiet environment and can’t stand fan and hard drive noise.
4. Reliable.  I can’t afford any extended downtime, data loss, or reoccurring blue screens, so I need the rig to be reliable.
5. Budget.  I want to stick as close as possible to the budget while achieving the first three requirements.

After lots of research, I ultimately came up with the following component list:

• Processor: Intel Core i7-860 Lynnfield 2.8GHz 8MB L3 Cache LGA 1156 95W Quad-Core Processor Model BX80605I7860
• Motherboard: GIGABYTE GA-P55-USB3 LGA 1156 Intel P55 USB 3.0 ATX Intel Motherboard
• Memory: G.SKILL Ripjaws Series 4GB (2 x 2GB) 240-Pin DDR3 SDRAM DDR3 1600 (PC3 12800) Desktop Memory Model F3-12800CL9D-4GBRL (2x, for 8GB total)
• Boot Drive: Intel X25-M Mainstream SSDSA2MH080G2R5 2.5″ 80GB SATA II MLC Internal Solid State Drive (SSD)
• Video Card: EVGA 512-P3-1242-LR GeForce GT 240 Superclocked 512MB 128-bit GDDR5 PCI Express 2.0 x16 HDCP Ready Video Card
• Power Supply: COOLER MASTER Silent Pro 700 RS-700-AMBA-D3 700W ATX12V V2.3 SLI Certified CrossFire Ready 80 PLUS Certified Modular Active PFC Power Supply
• CPU Cooler: ZALMAN CNPS10X QUIET 120mm 2 Ball CPU Cooler

Since I/O has almost always been the slowest aspect of my machines, I really wanted to go with an SSD as my boot drive.  I have heard nothing but fantastic things about the Intel X-25M, so I decided to go with it.  I also really wanted an i7, and the price for the i7-860 is a great value.  Additionally, to satisfy the low-noise requirement, I went with the upgraded Zalman cooler and the Cooler Master Silent Pro power supply.

Initial Results

I’ve been using this new development rig for about two weeks now, and it has absolutely blown away my expectations.  For my $1100 budget, I expected a great machine with room for improvement.  But, the machine’s performance is absolutely fantastic.

The SSD makes all the difference in the world.  Windows boots in seconds, and applications load instantly.  The splash screens for applications like Visual Studio 2010, Photoshop CS5, and Microsoft Office only appear for a split-second before the actual application loads.  I cannot recommend the Intel X-25M enough – it is incredible as an OS and program drive.

To top it all off, the machine is quiet.  Like, real quiet.  Sometimes I have to look under the desk to see if the power light is illuminated because the fans are almost completely silent.

I could not be more pleased with the result of this build.  The performance of this budget rig has made me so much more productive, since I don’t have to wait for any of my clicks or keystrokes to register.  And, the reliability and low noise levels keep me focused on the tasks at hand.

The list contains some other really great sample CodePlex projects that you should check out, such as the classic NerdDinner and TailSpin Travel.  All of the projects mentioned provide excellent code samples to help you new technologies and development techniques.  Check the out and learn something new!

http://www.codeguru.com/vb/vb_internet/aspnet/article.php/c17085

He also provides his code samples, which additionally use Windows Identity Foundation (WIF) and a custom STS. It’s a great starter project for anyone who’s looking into seeing how these tools work.

http://www.ryanmwright.com/2010/04/25/dynamic-controlleraction-authorization-in-asp-net-mvc/

Fatal error: Allowed memory size of 33554432 bytes exhausted (tried to allocate 122880 bytes) in /public_html/wp-admin/includes/template.php on line 699

The default memory limit setting is in the php.ini file, and many web hosts have it set to 12MB.  You can change it by modifying the php.ini file:

memory_limit = 64M

…but, many hosts don’t give you direct access to this file.

Instead, you can control the memory limit directly in your application.  In the wp-config.php file, just add a single line:

define('WP_MEMORY_LIMIT', '64M');

This issue came up on a recent project involving the BuddyPress WordPress plugin, which can be a fairly memory intensive module.  If you run into it, just bump up your memory limit and you should be fine.  If you’re using a platform other than WordPress, there are usually similar methods to define memory limits – just check the documentation for your particular application.

I will be blogging and tweeting LIVE from the event on www.caffeinedi.com and www.twitter.com/natedudek.

Although the schedule hasn’t been posted yet, I’ll be focusing mostly on the sessions related to Windows Azure, Silverlight 4, UX, MVC, jQuery, AJAX, and Visual Studio.  The sessions that are currently on my short list are:

• Building Platforms and Applications for the Real-Time Web
• The HaaHa Show: ASP.NET MVC Security with Haack and Hanselman
• What’s New in ASP.NET MVC 2 w/ Phil Haack
• Using Windows Identity Foundation For Creating Identity-Driven Experiences in Silverlight
• Developing with WCF RIA Services Quickly and Effectively
• Using Storage in the Windows Azure Platform
• Understanding the Model-View-ViewModel Pattern
• Stepping Outside the Browser with Silverlight 4
• Software and Web Entrepreneurs: Go Big with BizSpark and WebsiteSpark
• Silverlight and Windows Azure: A Match Made for the Web
• Silverlight 4 Overview – What’s in Store for Silverlight 4?
• Silverlight 4 Business Applications
• Search Engine Optimization for Silverlight
• Securing Silverlight Applications
• Improving Software Quality for the Modern Web
• Great User Experiences: Seamlessly Blending Technology and Design
• Driving Experiences via Services using the .NET Framework
• Designing and Delivering Scalable and Resilient Web Services
• Design the Ordinary, Like the Fixie
• Connecting Your Applications in the Cloud with the Windows Azure AppFabric
• Building Offline Web Apps Using Sync Framework
• Building Finance Applications with Silverlight 4
• Building Facebook Apps with .NET and Deploying to Azure
• Building a Next-Generation Web Application with ASP.NET MVC 2 and jQuery
• Six Things Every jQuery Developer Must Know w/ Elijah Manor
• Total Experience Design
• The Laws of User Experience
• Modern Web Form Design
• Design Fundamentals for Developers (and other Non-Designers)
• Cloud Computing Economies of Scale

Obviously, there’s LOTS of amazing content planned.  I won’t be able to attend every session I listed, but at the very least I’m hoping to catch up with some of the presenters of the sessions I’m not able to make it to.  I’m also hoping to sit down with guys like Elijah Manor and Clemens Vasters for a few minutes.

If you have things you’d like me to check out for you, or questions you’d like me to ask presenters or other attendees, drop me an e-mail, leave a comment, or send me a direct message on Twitter.

Fueling Your Application’s Engine with Windows Azure Storage

Hours of great content here… I have a feeling my wife is going to have to peel me away from the computer.  Maybe I’ll just watch them from the Windows Media Center box I have hooked up to the big screen and try to convince her they’re movies.

Introductory

• Lap Around the Windows Azure Platform
• Windows Azure Present and Future
• Introduction to Building Applications with Windows Azure
• The Business of Windows Azure: What you should know about Windows Azure Platform pricing and SLAs

Learn to Develop for Windows Azure

• Tips and Tricks for Using Visual Studio 2010 to Build Applications that Run on Windows Azure
• Patterns for Building Scalable and Reliable Applications with Windows Azure
• Developing Advanced Applications with Windows Azure
• Windows Azure Monitoring, Logging, and Management APIs
• Automating the Application Lifecycle with Windows Azure
• Building Hybrid Cloud Applications with Windows Azure and the Service Bus
• Enabling Single Sign-On to Windows Azure Applications
• Bridging the Gap from On-Premises to the Cloud

Windows Azure Storage

• Storing and Manipulating Blobs and Files with Windows Azure Storage
• Windows Azure Tables and Queues Deep Dive

Windows Azure as an Open Platform

• Developing PHP and MySQL Applications with Windows Azure
• Building Java Applications with Windows Azure

SQL Azure Sessions

• Enrich your Applications with Data from Microsoft Project Code Name “Dallas”
• SQL Azure Database: Present and Future
• Using the Microsoft Sync Framework to Connect Apps to the Cloud
• The Future of Database Development with SQL Azure
• Microsoft SQL Azure Database: Under the Hood
• Scaling out Web Applications with Microsoft SQL Azure Databases
• Petabytes for Peanuts! Making Sense out of “Ambient” Data
• Development Best Practices and Patterns for Using Microsoft SQL Azure Databases

Showcases

• Lessons Learned: Building Scalable Applications with the Windows Azure Platform
• Lessons Learned: Building On-Premises and Cloud Applications with the Service Bus and Windows Azure
• Lessons Learned: Building Multi-Tenant Applications with the Windows Azure Platform
• Lessons Learned: Migrating Applications to the Windows Azure Platform

One of the most informative things I’ve seen is a post by Bill Evjen which details the hardware behind Windows Azure.  Microsoft had one of the Azure data center “containers” set up at PDC, and the post takes you through it, all the way down to the cooling and humidity control.

It’s a fun read with lots of pictures.  Thanks Bill!

http://geekswithblogs.net/evjen/archive/2009/11/20/136437.aspx