Calling all .NET developers! This workshop will introduce you to writing native applications geared for the Android Platform based on .NET/C#/Mono. We’ll examine the overall architecture of MonoDroid, discuss how it integrates with Visual Studio, debug with MonoDroid, and look at a couple of example apps written with MonoDroid.

This session is for the .NET developer that wants to move to Android. While the session will be introductory for the Android platform, it will be advanced for those on the .NET Platform.

Native Android development is predominantly with the Java Language based on the Dalvik Java virtual machine using the Eclipse IDE. But if you or your company have already made a significant investment in .NET, the time to learn Java and Android is significant. Fortunately, there’s another way! You’ll be able to take your existing knowledge of .NET/C# and Visual Studio and immediately apply this to writing apps for Android using the Novell MonoDroid plugin.

Outline:

• Introduction to Android. This will provide an overview of the Android platform, acceptance in the marketplace, and basic capabilities.
• Introduction to Mono and the MonoDroid plugin for Visual Studio, MonoDroid for the Mac, and support for MonoDevelop for Windows.
• Basics of UI Design. This will provide information on how to create a user interface with Android and how the user interface is compiled into a MonoDroid application. We’ll see the same application running on a phone as well as tablet. We’ll look into some ways to take advantage of tablets from a UI perspective.
• Screen Controls. This section will provide the basics of user interface controls, screen issues, menus, various keyboards and widgets.
• Data Controls. This section will discuss how to successfully display data to the user. 
• Application States. This will be an overview the various states of an application in Android.
• Working with Local Data. This will be an overview of how to work with data locally on a device.
• Working with Remote Data. We will discuss strategies for working with remote data
• Multimedia. This section will discuss how to work with multimedia and graphics.
• How to perform background processing with threads and services.
  

While Android has been created for mobile devices -- phones first and now tablets -- it can, nonetheless, be used as the basis of any touch-screen system, whether it be mobile or not.  Essentially, Android is a custom-built embedded Linux distribution with a very elaborate and rich set of user-space abstractions, APIs, services and virtual machine. 

This one-day workshop is aimed at embedded developers wanting to build touch-based embedded systems using Android.  It will cover Android from the ground up, enabling developers to get a firm hold on the components that make up Android and how they need to be adapted to an embedded system.

Specifically, we will start by introducing Android's overall architecture and then proceed to peel Android's layer one-by-one.  First, we will cover the Android Open Source Project (AOSP), the open-source project under which Android's source code is released.  We will then dig into the native Android userspace, Android's power tools, and cover how hardware support is implemented in Android.  Given that Android is built on top of Linux, we will also go over some embedded Linux tricks and see how the kernel is modified to support the Android user-space.  In addition, we will look at the System Server, the Android Framework and core Android applications, and how to customize them.

Come to this hands-on-lab to be introduced to Android tablet development. We'll build out a simple android application, which showcases features of the new Android Tablet APIs. First, we will cover a short synopsis of what is new in Android Tablet development and then we will dive right in, creating an application which allows users to utilize the action bar, fragments, emulator and more. You will build an app that works on small screen devices, as well as large screen devices. We'll briefly touch on the new Android widgets, RoboGuice integration and internationalization.

By the end of this course you'll have the necessary tools in your Android tool belt to understand and create compelling Android Tablet applications. The benefits of this class are:

• Understanding device size compatibility (single code base for small screen-phones/xlarge screen-tablets)
• Mastering the new key components of the Android SDK for Tablets
• Learn shortcuts and tips and tricks from a seasoned Android veteran
  

WHAT TO BRING:

Please bring a laptop running either Linux, Mac OS X (Intel) or Windows. The machine should have:

• Eclipse Installed
• Android SDK Installed
• Android ADT Installed
  

Installation instructions are at  http://d.android.com/sdk/installing.html

TyphonRT is a middleware SDK that spans J2SE and Android. This workshop will teach you how to create a simple 2D game and then a Quake 3 class 3D engine called Auriga3D using TyphonRT. In addition, many pertinent game development topics will be explained with the goal of your building and understanding of non-trivial BSP-based engine by example. These topics include:

• Fundamentals: timing/clocking, input control, media assets
• OpenGL ES 1.x overview: state system, textures, billboards/particle systems
• Fundamentals II: rotation, bounding volumes, physics (motion / collision)
• Quake 3 Essentials: potential visibility sets (PVS), binary space partitioning (BSP) trees, frustum culling, lightmapping
• Entity Systems: a system of everything / component oriented programming
• OpenGL ES 2.x discussion: time permitting, a brief overview of shaders
  

OpenGL ES 1.x is the main graphics API to be discussed. We’ll also cover component-oriented programming and in particular the component-oriented entity system available with TyphonRT. Bring your laptop and Android device and get ready to dive in going from zero to game on!

This workshop is hands-on and tutorial materials will be available to direct attendees of the workshop. The first section of the workshop from 9:00 am - 10:30 am is organized around installing and setting up all developer tools necessary to build TyphonRT and the workshop demo code. Please arrive with a laptop and Android device on hand. The Android SDK, Java, and IntelliJ Idea Community Edition or Eclipse is the required IDE and will be installed as part of preparing the materials as a take away and for in-workshop usage.

If possible, please install the Android SDK, Idea or Eclipse, and JDK v6+ in advance as these tools form the standard Android developers setup. The conference presenter will be available to assist in installation of all materials and developer tools during the first section of the workshop. Attendees of all skill levels are welcome. The remainder of the workshop is split into three, roughly one and half hour sessions, covering the topics described above with a dedicated Q/A period reserved at the end of each.

This hands-on workshop will consist of critiques and walkthroughs of your applications with an eye to making them easier to use.  We will do some user testing and bounce ideas off each other. We will hack up screens and look for ways to better meet your goals.  Our goal is to make sure that everyone leaves this workshop with at least 1-3 usability improvements made to their application, and a list of 2-3 other things that can be done.

Visage is a domain-specific language for writing UIs that deploys to native code on Android devices. It excels at rapid application design, reducing the amount of boilerplate you have to write to create great looking UIs.

In this lab, you will have an opportunity to write Visage applications that deploy to and run on Android mobile devices. To participate in this session you will need a laptop running Windows, Mac OS X, or Linux. We will distribute a VirtualBox install and image via thumb drives, letting you get up and running very quickly with no reliance on the conference network.

If you ever find yourself making graphical decisions on your application, this session is for you. This hands-on workshop will consist of critiques and walkthroughs of your applications with an eye to making them look amazing.  We will open up Photoshop and hack up screens and try new things.  

We will look at best practice applications and give some tips on how to get there. Our goal is to make sure that everyone leaves this workshop with a list of design improvements that you can make to your own applications — and a list of other things to be done as well.  We can't make you a designer in one workshop, but we can help you with that next step up.

Go from your first unit test to a continuous integration server build! This two-part class will introduce you to reasons for automating the testing of your applications and then go on to show you how it can be done. You will learn about unit tests of plain Java classes running on the JVM.

After learning the difference of code running on the JVM and the Dalvik VM and the associated Android stack, you will see how to write integration (or instrumentation) tests with the features supplied by the Android SDK. After that you will see how Robotium builds on top of that and how Robolectric takes a completely different approach by running on JVM with mocked classes instead. Comparing and combining the approaches, we will finally get it all running on the continuous integration server Hudson.