Frode Nilsen's Techblog

Declarative UI and UDF with Android Databinding in XML

2022-12-20T04:41:00.006-08:00

Introduction

I know: A lot of buzzwords. Except Databinding, which is kind of the opposite. The thing is I've been a big fan of Android Databinding since its release in 2016 because I think it did good for a lot of the architectural issues that Android was suffering from. When Jetpack Compose came along people praised it for many good reasons but also for wrong ones. The word "declarative" was thrown around a lot, and conversely "imperative" when talking about legacy Android XML (example sources: ([1], [2], [3]). I felt that we were given the option to do declarative UI architecture already with Android Databinding but everyone seemed to have missed. Was I crazy?

With the example project shown below I wanted to prove to myself that declarative UI could be done with Android XML Databinding. As a developer with "senior" in the title, I'm obliged to truly understand the meaning behind the buzzwords in the title of this post. If you too are an Android developer feeling the slightest uncertainty about the meaning of those, please grant yourself a couple of minutes to read and understand as well. And if I've missed anything or misunderstood I'm happy to be corrected.

What I made is a a proof of concept app that illustrates how Android Databinding with XML can be declarative - simply by using a declarative ViewModel written for compose and applying that to a databound XML view. I will go in depth about that in a second - but first a bit more about the terms "declarative" and "imperative":

Making XML with Databinding declarative

First of all, there's nothing inherent in XML combined with Java/Kotlin that makes it imperative. The language expressing the UI does not define the UI paradigm. It's how you use that language. I think StackOverflow is a good source for finding the consensus here. I'm not saying "truth" because I'm not sure there is a single truth. Some say it is a spectrum and not a binary definiton.

Anyway, this accepted answer states:

The term is more often used for UI frameworks with a strict separation of the look of the UI from the behavior, which means the code reacting to UI events. For example, using XAML, you declare the look of your UI in a specific XML dialect, but you implement the behavior in separate program code.

Notice how he uses XAML as an example here. XAML is XML, just as Android's legacy view system is. It's not the markup lanugage, is the fact that we often use events to procedurally mutate dependent views that make it declarative. Oh and separation of looks from behaviour? Definitely well separated. They're even in different langauges as opposed to Compose.

The other answer is good as well, as it highlights that it's about describing WHAT instead of HOW. A view that's repeated in this blog post from Luns Muema.

Declarative UI is a UI that's designed in a declarative way (you describe what it should be like) rather than an imperative way (you code the steps to create it.)

The definition used by the Flutter documentation (which is a declarative UI framework) also resonnates surprisingly well with Databinding in XML if you use it the way I do here.

Here, rather than mutating an old instance b when the UI changes, Flutter constructs new Widget instances. The framework manages many of the responsibilities of a traditional UI object (such as maintaining the state of the layout) behind the scenes with RenderObjects. RenderObjects persist between frames and Flutter’s lightweight Widgets tell the framework to mutate the RenderObjects between states. The Flutter framework handles the rest.

As in Compose and in this example, Flutter uses immutable state. The framework, Flutter, constructs new widget instances. In our case, the Databinding framework, constructs new widget instances or mutates existing.

I'll take one more example: This blog post by Kaan Enes states

A declarative UI pattern defines the UI as a function of the “state.” A “state” is nothing but a variable or an object that holds a value, which can change based on user input or other business logic. When the state changes, the framework will redraw the UI

Again, this is exactly what happens with my immutable state bound to data in XML below.

What I did

So let's get one thing straight first. Android Databinding out of the box is not inherently declarative. I had to come up with a set of rules you need to follow to get both a 100% declarative pattern and unidirectional data flow (UDF) working:

One-way databinding only. The second we introduce two-way binding we mutate view state.
Never write logic in your XML binding. Instead bind to a single property from the ViewModel.
Your view state must be immutable
Your view model must expose one single observable field: The view state

For point 1 this means that you have to stick to @{viewModel.prop} only, never the @={}-syntax. So for instance for EditText's where it would be natural to use two-way binding for the text property in traditional Android Databinding, you'd instead have to bind to the event onTextChanged and let the ViewModel create a new state from that.

To elaborate on number 2: Not under any circumstance should you write expressions in XML:

android:text="@{state.name}" is cool.
android:visibility="@{state.personList != null && state.personList.count > 0}" is horrible and you should take a four month unpaid leave to contemplate about your life choices.

This is a good rule even if you don't go for declarative UI. It simply makes the code more testable.

Point 3 and 4 from above should be familiar if you've done Compose.

This diagram illustrates the setup:

If you've written compose apps you should be familiar with differentiating between ViewModel and ViewState:

The ViewModel is the Kotlin file that inherits from androidx.lifecycle.ViewModel and has the responsibility of changing the state. "Changing" means copying the state and changing one or more properties. You may bind events to the ViewModel but not properties.
The ViewState is an immutable Kotlin class that represents whatever changable state you see in the view. This is where you bind your XML properties to.

So this sets the stage for declarative UI where the state defines the UI completely and you can do cool stuff like state history playback.

Unidirectional Data Flow

UDF is an important concept in Compose. You need to understand that properly in order to succeed with declarative architecture with Databinding. The basics is that events bubble up and state trickle down in the view hierarchy. Let's take this trivial example:

You have a password input field and a "Continue" button. Whenever the password field is empty the Continue button should be disabled. Once a single character is entered, the buttons should enable. Illustrated:

With UDF and declarative programming you do not let the EditText alter the button state directly. Nor do you let the Button read the state of the EditText to determine its enabled-state (although that may comply to declarativism but not UDF?). Instead you let the textChanged-event bubble up to the ViewModel, which alter the state object and passes it down to the button.

Example project

Github link: https://github.com/Nilzor/declarative-databinding

The example project I wrote is a bit more complicated. It is the sketch of an app selling public transport tickets with an arbitrary number of traveler type categories. I've set the data to have three categories: Adult, Child and Bicycle. You enter the number of each category by using increase/decrease buttons and get a total summed at the bottom

The project is implemented both using Jetpack Compose and XML Databinding. It shares a common ViewModel and ViewState. There is just a thin wrapper around the ViewModel to allow the Android Databinding to pick up on changes. I convert the StateFlow to an Observable. You can see that in the file ShoppingCartViewModelDataBinding.

If you look at the ViewState it represents the views pretty much one-to-one:

The challenge here lies in the introduction of the list (RecyclerView for the XML). You need to propagage the event happening at the leaf node when you increase or decrease the traveler count to the top and then alter the "Total count". With Jetpack Compose this is pretty trivial. With Databinding you have to do a bit more grunt work. First of all I use Evan Tatarka's binding-collection-adapter which allows me to databind to list items without writing adapters (more tips here). But I then encountered the issue that the elements in the list do not have access to the root ViewModel for event propagation. It is bound directly to the sub-state that only expose a single list item. There might be several ways to solve this but I chose to bind the event directly to the root Activity, as that is always "exposed" by simply using the legacy android:onClick="handleClick" syntax, which requires of you to write a function in the Activity that takes a single View parameter as input. The activity then passes that event on to the ViewModel. There may be better ways to solve this, but it worked for me. The architecture for Databinding is then a slightly altered:

Example flow

I know you all don't have time to download the example project so here I illustrate a flow of three steps with the state data model alongside screenshots for both the Jetpack Compose rendering and Android XML Databinding:

State 1: Add 1 adult
State 2: Add 1 child (sum: 1 adult, 1 child)
State 3: Add 1 child (sum: 1 adult, 2 children)

STATE 1    
    
PageState(
  productList = [
	  ProductCounterState(
		count = 1
		enableDecrease = true
		name = "Adult"
	  ),
	  ProductCounterState(
		count = 0
		enableDecrease = false
		name = "Child"
	  ),
	  ProductCounterState(
		count = 0
		enableDecrease = false
		name = "Bicycle"
	  )
	]
  totalProductCount = 1
)

STATE 2

PageState(
  productList = [
	  ProductCounterState(
		count = 1
		enableDecrease = true
		name = "Adult"
	  ),
	  ProductCounterState(
		count = 1
		enableDecrease = true
		name = "Child"
	  ),
	  ProductCounterState(
		count = 0
		enableDecrease = false
		name = "Bicycle"
	  )
	]
  totalProductCount = 2
)

STATE 3

PageState(
  productList = [
	  ProductCounterState(
		count = 1
		enableDecrease = true
		name = "Adult"
	  ),
	  ProductCounterState(
		count = 2
		enableDecrease = true
		name = "Child"
	  ),
	  ProductCounterState(
		count = 0
		enableDecrease = false
		name = "Bicycle"
	  )
	]
  totalProductCount = 3
)

Compose screenshots

Databinding screenshots

In short: The presentation is correct both for Compose and Databining with a code base that share the exact same ViewModel/ViewState file. There is no noticable lag or flickering in the UI for any of the view implementations.

The example project also contains a bonus rewind / replay functionality for the databinding example for those who want to play around with that. Notice the buttons on the bottom of the activity when starting the Databinding Activity (cropped out of the screenshots). This was trivial to implement by wrapping the ViewModel in a history-holder.

Conclusion

I did this experiment to prove to myself that I understood what declarative UI really was and that my gut feeling that you could do declarative UI in with Android Databinding in XML. I'm not saying that I will use use this pattern going forward or that I recommend others to use it, but you should be aware of the possibility. If your app contains legacy Android XML views with imperative logic and you're looking to rewrite it, it will be just a big of a job to go to Delcarative XML using Databinding as it would be to rewrite it to Jetpack Compose. The latter option would be the best options in most cases, as Jetpack Compose has a bunch of other benefits that I have not dug into here.

Jetpack Compose is awesome, but Android databinding with XML can be awesome too if used correctly.

Filling the gaps of Android Databinding

2022-08-28T11:01:00.000-07:00

tl;dr

Library	Description
binding-collection-adapter	Bind RecyclerView, ListView, ViewPager and Spinner
bindable-radiobuttons	Bind RadioButton, ToggleButton, Checkbox and lists of Buttons
useful BindingAdapter	Reduce boilerplate further and the need for common support properties

Library

Description

binding-collection-adapter

Bind RecyclerView, ListView, ViewPager and Spinner

bindable-radiobuttons

Bind RadioButton, ToggleButton, Checkbox and lists of Buttons

useful BindingAdapter

Reduce boilerplate further and the need for common support properties

Introduction

The Android Databinding library is tried and tested tool for enabling MVVM architecture in your Android apps. It helps you move code from your activities, fragments and views to your ViewModel. From the outset the library lacked what I belive to be some core features, like binding to RecyclerView and groups of RadioButtons. In this article I will present a couple of libraries that fill these gaps and more.

With these simple add-ons I believe DataBinding is a highly effective and fun way of coding solid unit-testable MVVM apps on Android.

List- And RecyclerViews

Evan Tatarka's Binding-Collection-Adapter library solves binding to RecyclerViews elegantly. You have one XML view for the individual items and a ViewModel class that represents them. If you have multiple view types for the list you can override the binding code.

This solution rids of the adapter. Less code. Better architecture. It also suppoerts ListView, Spinner and ViewPager

Example

Below is a minimal example to lay out the concept. A RecyclerView with two bound, each item has the text and the color property bindable. Read the official documentation for a complete, compilable example.

Result:

Main view:

<androidx.recyclerview.widget.RecyclerView
	android:layout_width="match_parent"
	android:layout_height="match_parent"
	app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
	app:items="@{viewModel.items}"
	app:itemBinding="@{viewModel.itemBinding}"/>

Item view:


<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable name="itemVM" type="com.nilsenlabs.bindingblog.ItemVM" />
    </data>
    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="@{itemVM.text}"
        android:textColor="@{itemVM.color}">
    </TextView>
</layout>

Main ViewModel


class MainVM {
    val items: ObservableList = ObservableArrayList()
    val itemBinding: ItemBinding = ItemBinding.of(BR.itemVM, R.layout.item)

    init {
        items.add(ItemVM("One", Color.BLACK))
        items.add(ItemVM("Two", Color.GREEN))
    }
}

Item ViewModel


class ItemVM(
    val text: String,
    val color: Int
)

RadioButtons, CheckBoxes and list of Buttons

This one I built myself: I needed to bind a list of RadioButtons to data fetched from a remote service. The number of RadioButtons will vary. A common use case (with or without the service), but not supported out of the box from Google's Data Binding library. My library, bindable-radiobuttons, also support check boxes, toggle buttons and regular buttons. To produce the screenshot below implement the following:

View:


<com.nilsenlabs.bindableradiobuttons.radiobuttons.BindableRadioButtonList
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:orientation="vertical"
	app:itemViewId="@layout/my_radio"
	app:selectedItem="@={viewModel.selectedRadioButton}"
	app:buttons="@{viewModel.radioButtons}"
	/>

ViewModel


val radioButtons = listOf(
	RadioButtonViewModel("One"),
	RadioButtonViewModel("Two", isEnabled = false),
	RadioButtonViewModel("Three")    
)
val selectedRadioButton = ObservableField<RadioButtonViewModelInterface>(radioButtons[2])

Useful Binding Adapters

You need a handful of extra binding adapters on top of what Google provides to solve a set of common use cases.

Gist with BindingAdapters on Github here

Name	Input type	Binds to	Function
app:visibleOrGone	Boolean	Visiblity	true means Visible, false means Gone. My number 1 most used binding adapter.
app:visibleOrInvisible	Boolean	Visiblity	true means Visible, false means Invisible
app:goneIfNull	Any	Visiblity	null means Gone, non-null means Visible. Perfect if you want a text view to be gone when the String is null.
app:onClick	None	clickListener	Just a click listener that doesn't send "view: View" as unnecessary input parameter
android:src	Int	src	Allows you to bind a drawable resources as Int to an ImageView. Google only allows Drawable objects out of the box, which will force you to depend on a Resource object in the VM
android:text	Int	text	An improvement to standard TextView text binding that doesn't crash when the value 0 is bound.

Name

Input type

Binds to

Function

app:visibleOrGone

Boolean

Visiblity

true means Visible, false means Gone. My number 1 most used binding adapter.

app:visibleOrInvisible

Boolean

Visiblity

true means Visible, false means Invisible

app:goneIfNull

Any

Visiblity

null means Gone, non-null means Visible. Perfect if you want a text view to be gone when the String is null.

app:onClick

None

clickListener

Just a click listener that doesn't send "view: View" as unnecessary input parameter

android:src

Int

src

Allows you to bind a drawable resources as Int to an ImageView. Google only allows Drawable objects out of the box, which will force you to depend on a Resource object in the VM

android:text

Int

text

An improvement to standard TextView text binding that doesn't crash when the value 0 is bound.

Getting Google Nest Hello Visitor Announcements to Automatically Show on the Google Hub

2020-04-19T01:28:00.001-07:00

This checklist is for users of the Google Nest Hello connected with Google Nest Hub having trouble
getting visitor announcements to automatically display on the Hub. It assumes the Hub is properly set up and connected to Google Assistant and Hello so that you can..:

Control the Google Nest Hub from your phone
See live video stream from your Hello by giving the voice command "Show <Hello_Room_Name>"

This checklist should help you solve the final problem:

Getting visitor announcements to automatically show on the Google Nest Hub when someone rings the Hello doorbell

On the Nest Hub device:

Do not disturb off (center button when swiping up from bottom)

Google Home app(s):

Click on your connected Google Hub Nest Device
Click settings and ensure:

Night mode: off
Recognition and Personalization > Allow Personal results: On

If you have multiple accounts associated with the Home make sure you check the settings for all accounts

Nest app:

Settings > Front door > Visitor announcemenbts: On

Screenshots:

Google Home, Hub device setup

Google nest:

Other issues:

For other issues some of these guides might help:

Official Gogle Nest Hub/Speaker getting started guide
Official Google Nest visistor announcement guide
Ensure wifi for the Hub correctly set up
For more questions visit Google nest support community

Data Binding with Android Architecture Components Preview

2017-05-22T01:00:00.000-07:00

In the talk Architecture Components – Solving the Lifecycle Problem from Google I/O 2017, Yigit Boyar talked about the new LiveData<T> class of the Architecture Components library. When talking about it it’s always coupled with the concept of the ViewModel. I’ve long been a fan of the MVVM pattern when doing mobile development so this was interesting to me. I’ve also been using the Android Databinding framework, so I was interested in seeing how this plays together.

tl;dr: Right now, they don’t. But let’s dig a bit deeper.

LiveData vs ObservableField

LiveData<T> was presented in a slide as:

An Observable data holder
Lifecycle aware
Automatic subscription management

In android data binding we find the sister class ObservableField<T>. If I were to write a similar slide for that one, it would be:

An Observable data holder

The difference is that ObservableField<T> isn’t lifecycle-aware and hence there cannot be any automatic subscription management. However the Android Data Binding framework does the subscription management for you – it’s just not directly aware of the lifecycle. Instead of immediately unsubscribing when a fragment pauses or stops, it has somewhat of a delay. Notice this memory dump from a bound ObservableField:

You see that the mListener is a ViewDataBinding$WeakListener. If you look at the ViewDataBinding class inner workings, you see that it uses a WeakReference to the views and view bindings. This ensures that whenever an Activity or Fragment is dead, the reference to the ViewModel and its ObservableFields are removed in due time. Just not immediately as you would get if it was lifecycle aware.

Using it with data binding

So the key question is – can we just swap all usages of Observable<T> with LiveData<T> in view models we use with Android Data binding? After all, they’re just observables with life cycle awereness.

Alas: No.

In the Android Architecture Components Sample app, it’s implemented rather cumbersome with boilerplate code which pipe data from one type of observables (LiveData) into another (Observable). This is why:

LiveData<T> cannot be bound to directly in XML.
The Android Data Binind framework doesn’t know how to observe on LiveData.

The first bullet point is easily fixable. We could just write a simple converter. The second one is not as simple though. At least not for us laymen. Google could fix it, and I hope they will. Notice the difference in the interfaces for subscribing on the two classes:

ObservableField.addOnPropertyChangedCallback(Observable.OnPropertyChangedCallback callback);
// versus
LiveData.observe(@NotNullLifecycleOwner owner, Observer observer)

You have to provide the LiveData-object with a LifecycleOwner. Per now, the Android data binding framework isn’t rigged to do that. But it could be, and I hope it will be soon. I notice that it’s Yigit Boyar who present these concept – the developer who’s also behind Android Data Binding. He should know how to tie these things together.

The ViewModel holder

Another interesting class introduced in the Android Architecture Component talks is ViewModelProviders. I’ve found it does three things:

Retains view models across device rotations and other lifecycle-affecting events
Rids of the view models on onDestroy
Saves and restores the view models helped by the Parcelable interface on onSaveInstanceState and onCreate *

*) Disclaimer: Very superficial research done here

The problem it solves is avoiding double calls to expensive services when a long-running request is interrupted by a lifecycle change. Illustrated by this slide in the talk, just to set the context:

I’m claiming that this class bring more value to the table for data binding users than the LiveData-class. It wasn’t very difficult to achieve before either, though. The Data Binding framework already allowed for this pattern as long as you implemented the holder class yourself.

Example: I made an improvement to my earlier MVVM example project where I’ve introduced a holder for the ViewModel-class accessed through a application-wide singleton. There wasn’t a lot of code change needed. You’ll notice after this commit that the “# logged in users” in the top right corner of the example activity doesn’t reset after device rotation using this technique – even if you interrupt the 2 second long initial load.

In the branch androidarch I solved the same problem using the ViewModelProviders-class from the Architecture Components. I also experimented with binding to a LiveData class instead of ObservableField, but found it not to bring any value to the architecture or solution due the arguments stated above.

Conclusion

I think the Android Architecture Components is a good set of components that for sure will make it easier for new developers to create a solid foundation from the start. The earlier examples from Google have rieked of bad practices and been riddled with pitfalls. But in terms of the interoperability with Android Databinding it seems very unfinished. Maybe they hoped to get it more done for Google I/O than what was presented. In any case I look forward to the next versions of this library and its migration into the support framework.

Two way data binding without RxJava

2016-10-16T01:43:00.000-07:00

A couple of weeks ago, this article by Radosław Piekarz got some tracktion on /r/androiddev. While I am a fan of RxJava myself we use it extensively in our apps at VG.no, I feel this example was not the best use case for it. As others point out in the comment field, this can easily be solved without RxJava. Here is how:


public MainViewModel() {
    OnPropertyChangedCallback buttonUpdater = new OnPropertyChangedCallback() {
        @Override
        public void onPropertyChanged(Observable sender, int propertyId) {
            updateButtonEnabledState();
        };
    };
    firstName.addOnPropertyChangedCallback(buttonUpdater);
    lastName.addOnPropertyChangedCallback(buttonUpdater);
}

private void updateButtonEnabledState() {
    boolean enable = StringUtils.isNotNullOrEmpty(firstName.get()) &amp;&amp; StringUtils.isNotNullOrEmpty(lastName.get());
    helloButtonEnabled.set(enable);
}

What I’ve done is recoded the constructor of the viewmodel for MainActivity to hook onto the OnPropertyChanged callback of the ObservableFields for the two TextViews directly, instead of going through the hoop of RxUtils.toObservable.

You can furthermore clean up the code by writing an adapter for the OnPropertyChanged callback, which as it is is not very lambda-friendly. Introducing the helper class BindingCallbackAdapter:


public class BindingCallbackAdapter extends Observable.OnPropertyChangedCallback {
    private Callback mCallback;

    public BindingCallbackAdapter(BindingCallbackAdapter.Callback callback) {
        if (callback == null) throw new IllegalArgumentException("Callback cannot be null");
        mCallback = callback;
    }

    @Override
    public void onPropertyChanged(Observable sender, int propertyId) {
        mCallback.onChanged();
    }

    public interface Callback {
        void onChanged();
    }
}

..and the more readable MainActivity-constructor:


public MainViewModel() {
    OnPropertyChangedCallback buttonUpdater = new BindingCallbackAdapter(this::updateButtonEnabledState);
    firstName.addOnPropertyChangedCallback(buttonUpdater);
    lastName.addOnPropertyChangedCallback(buttonUpdater);
}

See full fork at github.

While I’m sure the author of the original article is aware of the possibility of this implementation, I’m afraid that too many blog posts about “RxJava for everything” spreads antipatterns. I do understand that there are cases where this could be a good pattern, for example if you need to compose the onPropertyChanged events in more complex Rx-flows, but this concrete use case is not one.

Async programming patterns in different languages

2016-08-13T10:23:00.002-07:00

During the 10 years I've been into professional programming, the largest paradigm shift I've witnessed is the one from sequential to asynchronous programming. Not that it is a new concept - asynchronousity has been has been present in programming since the dawn of time, but what's new is the tight integration in programming languages and the prevalence of it. From events and callbacks in C# to async-await. From callbacks in Javascript to Promises. In Java we got Futures in Java 7, CompletableFuture, lambdas and streams in Java 8. On top of all these language features you have a vast array of libraries that help you implement common async patterns - ReactiveX for instance exists for all the three languages mentioned, and a lot more. I've been programming quite a bit in all the three languages mentioned: C#, Java and Javascript, and I realized I had to re-learn all the same patterns over and over again. On top of the languages features there were libraries as well. Multiple for each language. In this blog post I will iterate what I believe are the 3 most common patterns, list and compare them in these languages. I welcome contributions for other languages or patterns to this github repo - let's together make this more a reference than a blog post! The patterns I most often use are the following: serial execution, parallel execution where you must wait for all to complete, and parallel execution where you just want the first result to return. I'm also most often using these pattern in relation to network transfers (HTTP). So first I will illustrate the three patterns with different use cases:

Use case 1: Serial execution of HTTP calls

Let's say you're building a user interface which depends on two REST services. One provide a list of news article items, while the other is an image hosting service which return image binaries from URL's. The first service returns URL's which are to be used as input for the second service. This makes second operation dependent on the first - they have to be executed serially:

Use case 2: Parallel execution, wait for all

This time the user interface is composed of data from two independent services. You want to display a blank screen with a progress bar only while loading. Only when all data is fetched, you start rendering. This is what I dub the form-merge parallel execution:

Use case 3: Parallel execution, take first

In this case you're firing multiple HTTP queries to identical services, but only care for the response from the first to reply. It might be that you're building a performance-critical application, or you have multiple 3rd-party providers delivering the same service but with varying degree of reliability.

Implementation

Below is listed short examples illustrating the three patterns in the different languages, with support functions in the first chapter. For Java I've chosen to use the RxJava framework simply because that's what I know best. If you know how to do the same with plain Java (8), please let me know or contribute with a pull request to the repo!

Support functions

Javascript / ES6-Promise

// Resolves the input value after 300ms
function getSlowPromise(returnValue) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve(returnValue);
        }, 300);
    });
}

C#

// Returns input string after 250ms
public static async Task<string> GetSlowStringTask(String toReturn)
{
    await Task.Delay(250);
    return toReturn;
}

// Returns input int after 250ms
public static async Task<int> GetSlowIntTask(int toReturn)
{
    await Task.Delay(250);
    return toReturn;
}

Kotlin

suspend fun getSlowStringJob(s: String) : String {
    delay(250)
    return s
}

suspend fun getSlowIntJob(i: Int) : Int {
    delay(250)
    return i
}

// Returns the deferred job which completes first
suspend fun <T> awaitFirst(jobs : Array<Deferred<T>>) : Deferred<T> {
    var doneJob : Deferred<T>? = null
    while (doneJob == null) {
        for (job in jobs) {
            if (job.isCompleted) {
                doneJob = job
                break;
            }
            yield()
        }
    }
    return doneJob
}

Pipeline / Serial execution

Javascript / ES6-Promise

// createPromise is a method returning a promise which resolves to the input value
getSlowPromise('job1')
    .then((result) => {
        return getSlowPromise(result + '-job2');
    }).then((result) => {
        return getSlowPromise(result + '-job3');
    }).then((result) => {
        // Result from third job
    });

Java / RxJava

Observable<String> obs1 = Observable.just("Hello world");
obs1.flatMap(s -> {
    Observable<Integer> obs2 =  Observable.just(s.length());
    return obs2;
}).flatMap(i -> {
    Observable<String> obs3 = Observable.just("Length: " + i);
    return obs3;
}).subscribe(s ->{
    System.out.println(s);
    // Will output "Length: 11"
});

C#

var str = await GetSlowStringTask("Hello world");
var len = await GetSlowIntTask(str.Length);
var res = await GetSlowStringTask("Len: " + len);
Console.Out.WriteLine(res);

Kotlin

launch(CommonPool) {
    val res1 = getSlowStringJob("Hello")
    val res2 = getSlowIntJob(res1.length)
    val res3 = getSlowStringJob("First string length: " + res2)
    System.out.println(res3)
}

Parallel fork-join

Javascript / ES6-Promise

// Assuming promise1, 2 and 3 are created
// before this code executing
Promise.all([
    promise1,
    promise2,
    promise3
]).then((results) => {
    // 'results' is array of results from each promise
})

Java / RxJava

// obs1, 2 and 3 are Observable<String>'s
// Assuming each observable only emits 1 value
obs1.mergeWith(obs2)
    .mergeWith(obs3)
    .buffer(3)
    .subscribe(resultArray -> {
        // resultArray is String[3]
    });

C#

var tasks = new Task<int>[3];
tasks[0] = GetSlowIntTask(1);
tasks[1] = GetSlowIntTask(2);
tasks[2] = GetSlowIntTask(3);
Task.WaitAll(tasks);
for (int i = 0; i < 3; i++)
{
    Console.Out.WriteLine("Res " + i + ": " + tasks[i].Result);
}

Kotlin

val job1 = async(CommonPool) { getSlowIntJob(1) }
val job2 = async(CommonPool) { getSlowIntJob(2) }
val job3 = async(CommonPool) { getSlowIntJob(3) }
launch(CommonPool) {
    val sum = job1.await() + job2.await() + job3.await()
    System.out.println("Sum: " + sum)
}

Parallel take first

Javascript / ES6-Promise

Promise.race([
    promise1,
    promise2,
    promise3
]).then((result) => {
    // result is first to return
})

Java / RxJava

// obs1, 2 and 3 are Observable<String>'s
// Assuming each observable only emits 1 value
obs1.mergeWith(obs2)
    .mergeWith(obs3)
    .first()
    .subscribe(result -> {
        // result is String
    });

C#

var tasks = new Task<int>[3];
tasks[0] = GetSlowIntTask(1);
tasks[1] = GetSlowIntTask(2);
tasks[2] = GetSlowIntTask(3);
int firstResult = Task.WaitAny(tasks);
Console.Out.WriteLine("Res " + firstResult);

Kotlin

val job1 = async(CommonPool) { getSlowIntJob(1) }
val job2 = async(CommonPool) { getSlowIntJob(2) }
val job3 = async(CommonPool) { getSlowIntJob(3) }
launch(CommonPool) {
    val jobs = arrayOf(job1, job2, job3)
    val first = awaitFirst(jobs)
    System.out.println("Finished first: " + first.getCompleted())
}

Thanks to Espen Volden for contributing with Javascript examples

Article updated 18 Feb 2017 with Kotlin 1.1 Coroutines examples

Android Data Binding: Goodbye Presenter, Hello ViewModel!

2015-07-17T05:07:00.000-07:00

The Model-View-Presenter-pattern (MVP) has been the dominating trend lately when it comes the UI-layer architecture of Android applications. Frameworks like Ted Mosby, Nucleus and Mortar have all talked about Presenters to help you achieving a clean architecture of your app. They also (to a variyng degree) help you with the infamous issues of device rotation and state persistence on the Android platform. This isn't directly related to the concept of MVP, but the pattern helps you isolate the boiler plate code.

Data binding, as announced on Google I/O 2015 and introduced in the Android M preview, changes everything. According to the Wikipedia article on MVP, the Presenter has the following tasks:

The presenter acts upon the model and the view. It retrieves data from repositories (the model), and formats it for display in the view.

The thing is that Data Binding framework will take over the main responsibilities of the Presenter ("acting upon the model and the view"), while the remainder is left to the enhanced Model - the ViewModel ("retreiving data from repositories and formatting"). The ViewModel is a standard Java class whose sole responsibility is to represent the data behind a single View. It can merge data from multiple sources (Models) and prepare that data for presentation. I did a short writeup on the ViewModel and how it differs from Data Model or Transport Model.

The architecture we end up with is MVVM - Model-View-ViewModel, and is a proven concept originally coined by Microsoft back in 2005 (don't let that scare you ;-) ). Let me illustrate the change from MVP to MVVM for you, shamelessly copying Hanne Dorfmann's illustration from the introduction of his Ted Mosby framework

So all the binding and updating of data to the view is done through the Data Binding Framework. The ObservableField class allow the View to react on changes to the model, and the XML references to fields allow the framework to push changes back to the ViewModel when the user acts upon the View. You can also programatically subscribe to changes in fields so that for instance a TextView is disabled when a CheckBox is clicked. One great advantage of representing the visual state of the View in a standard Java class like this is clear: You can easily unit test the visual behaviour.

Note that in the MVP illustration above there is a method call to Presenter.loadUsers(). This is a Command. In MVVM these are methods defined in the ViewModel. From the Wikipedia article:

The view model is an abstraction of the view that exposes public properties and commands

So this may or may not be a change to what you're used to. In the MVP pattern it's likely that your models were "dumb" classes only holding data. Don't be afraid of putting business logic in your Models or View Models as well. This is a core principle of Object Oriented Programming. So back to Presenter.loadUsers() - this will now be a method in the ViewModel and may be invoked programmatically by the code-behind* of your View or though a data bound command in the XML of your View. That is - if the promises of this issue in the android-developer-preview issue tracker hold up. If we don't get data binding to commands, we have to resort to the old android:onClick-syntax, or manually adding listeners in the View code as before.

*) "Code-behind" is a term from Microsoft, often with negative associations to early ASP.NET or WinForms. I think it's a describing term also on Android where the View is composed of two source elements: the View Layout (XML) and the Code-Behind (Java), represented by Fragments, Activities and classes extending View.java.

Dealing with system calls

There is one set of use cases which still have to be done in the code-behind of the View - functions which initate system calls, opens dialogs or basically any call which require reference the Context object of Android. Don't put code like this in the ViewModel. If it contains the line import android.content.Context;, you're doing it wrong. Don't do it. Kittens die.

I haven't quite made up my mind on the best approach to tackle this yet, but that's because there are several good options. One way would be to keep elements of the presenter concept from Mosby by referencing an interface to the View in the ViewModel. This way you won't reduce the testability. But instead of having a seperate Presenter class as in Mosby, I'd stick to the View as the concrete implementation of that interface just to keep it simple. Another approach could be to use an event bus like Square's Otto to initiate commands like new ShowToastMessage("hello world"). This will yield a greater separation of the view and the viewmodel - but is that a good thing?

Don't we need frameworks now?

So is the Data Binding framework taking over the job of framworks like Mosby or Mortar? Only partly. What I hope to see is these frameworks evolve or fork into MVVM-style frameworks so that we can leverage the best of Data Binding while keeping the dependencies to 3rd-party frameworks to a minimum, and keeping the frameworks small and simple. While the era of the Presenter might be over, the framworks do a just as important job with lifecycle management and view state (ViewModel) persistence. This has not changed (unfortunately*)

*) Wouldn't it be cool if Google introduced an interface LifeCycleAffected which Fragment, Activity and View implemented? And that interface had methods named addOnPauseListener() and addOnResumeListener()? I leave it up to you to what that might have done with our code base, and the code base of MVP/MVVM frameworks.

Summary

When I first heard that Android M was all about improving the SDK and focusing on the developers, I was really excited. When I heard they were introducing Data Binding, I was stoked. I have worked for years with data binding on other platforms : WinForms, WPF, Silverlight and Windows Phone. I know it will help us write cleaner architecture and less boiler plate code. The framework works with us instead of against us, as I've felt it has been for a long time.

But it's not a silver bullet - there are downsides. The fact that you define stuff in XML is an issue. XML is not compiled. XML cannot be unit tested. Hence you'll often end up noticing errors run-time instead of compile time. Forgot to bind the field to the view? Tough luck. But the tooling can help a great deal here - that's why I hope Google is focusing hard on making Android Studio support data binding to the max. Syntax and reference checking of the binding XML, auto complete and navigation support. Field renaming support which propagates to XML. From my testing of Android Studio 1.3 beta - I'm at least assured that the are thinking about it. Some things are supported. A lot isn't, but we're still in beta so here's hoping.

Code example

I've posted an example on github where I try to illustrate the conseqeunces of going from MVP to an MVVM architecture. I used Mosby as a framework in the MVP version with Butterknife for view injection. In the MVVM example I'm using Android M databinding and drop dependencis to both Mosby and Butterknife. The result is that the Presenter can be dropped, the Fragment gets less code but the ViewModel takes over a lot of the code. In some sense it actually acts partly as a presenter, in that it directly or indirectly notifies the view.

The example is a login screen with som async data loading and inter-view dependencies just for illustration purposes.

Checkout the MVP tag to see the MVP example and the MVVM for Databound MVVM

Don't forget the View Model!

2015-04-07T01:13:00.001-07:00

Background

I've observed an increase in architecture-focused Android posts lately in channels such as /r/androiddev and Android Weekly. That's great, but frankly it's about time. When I transitioned from Windows Phone development to Android a couple of years ago I felt it was difficult to find good examples on how to architect a solid app. It didn't help that Google's examples violated most best practices[1] either. I kind of went with my own version of MVVM (or MVPVM) which I had with me from the .NET platform and it sort of worked. Reading
Hannes Dorfmann's post on MVP and his Mosby framework, I realize I'm not the only one who've been struggling with getting the established patterns working with Android (he spent 3 years). The framework is not exactly leading you into a good architecture. Maybe Fragments is partly to blame, and why Square Inc is advocating against it.

In any case the community is steadily going in a direction where the good UI-architecture is common knowledge. Frameworks[2] are helping in that matter and blog posts like Dorfmann's and Artem Zin's post on the Model. Still, a term I seldom hear in the Android world is View Model - but there really shouldn't be a reason for it. The View Model concept fits nicely into any MVC/MVP pattern. In this post I'll explain how you can and should split your model into two or even three layers of models.

[1] An example is the Connecting to the Network-article. View, Model and presenter-code all in one file and the inner class DownloadWebpageTask have dependency to the Activity. Same mistake is done in Parsing XML Data. You could also question if they maybe should hint at 3rd-party libraries existing that greatly simplifies both XML-parsing and HTTP communication.

[2] In addition to Framework-libraries, smaller libraries or micro-frameworks such as Dagger, Flow, Mortar, Parceler, Icepick and RxAndroid are building blocks which paved the way for MVP-frameworks.

The different model types

The View Model

In this post I'm defining the View Model somewhat loosely as the model mirroring a concrete user interface. Martin Fowler names it the Presentation Model. It differs from the Business Model in that it has filtered, merged or converted data for presentation in one specific context. From this follows that you can have multiple View Models for one Business Model, or multiple Business Models represented in one View Model. In the Microsoft MVVM pattern it is tightly coupled with the Business Model through databinding. That is not a requirement in my definition and use, but it can certainly be implemented if that is a requirement in your project.

The Business Model

What I name the "Business Model" is the model representing an actual business entity. Think user, product , supplier or order in an online web shop system. In the Android code it contains strongly typed objects and business logic for working with these.

The Transport Model

I'm going to introduce a third model type I name "The Transport Model". You will not always need it and even if you do you will not always have it as a separate class. The Transport Model is the model representing the business model in transport. If you have a REST service, it will be the class representing the JSON-data. I've found it useful to separate this as a standalone class as it allows me to unit test the parsing easily as well as allowing for switching the transport protocol with as little friction as possible. The pattern works very will with parser libraries such as Gson or Jackson.

Example

I'm going to paint a scenario here with for a Movie Database app (heard it before?). The App fetches a list of movies with metadata from a JSON REST service and displays the list of movies in the app. Here is the JSON data:

{
    "v" : 1,
    "data" : [{
            "released" : "2011-08-04",
            "title" : "Hell on Wheels",
            "category" : "TV series",
            "id" : "tt1699748",
            "stars" : "Anson Mount, Colm Meaney",
            "image" : [
                "http://ia.media-imdb.com/images/M/MV5BMTQ5NTE5NTYzMF5BMl5BanBnXkFtZTgwOTc4OTY0MzE@._V1_.jpg",
                1297,
                1404
            ]
        },
        {
            "released" : "2014-04-02",
            "title" : "Hello Ladies: The Movie",
            "category" : "TV movie",
            "id" : "tt3762944",
            "stars" : "Stephen Merchant, Christine Woods",
            "image" : [
                "http://ia.media-imdb.com/images/M/MV5BMTQ5MjYxMjkwOV5BMl5BanBnXkFtZTgwODE3MjY0MzE@._V1_.jpg",
                1012,
                1500
            ]
        }
    ]
}

So this with this JSON blob i want to illustrate a typical issue: The data itself is wrapped in a somewhat unnecessary object (with the version identifier). You don't want this and other unnecessary data to bleed into your app business model. Also you want the date, image and list of stars as strongly typed data objects - so you create a set of Transport Models separate from the Business Model:

public class MovieJsonModel {
    public String released;
    public String title;
    public String category;
    public String id;
    public String stars;
    public ArrayList<Object> image;
}

public class MovieListJsonModel {
    String v; // Version
    public ArrayList<MovieJsonModel> data;
}

The classes above can be directly parsed from the JSON feed using a one-liner with Gson:

MovieListJsonModel transportModel = new GsonBuilder().fromJson(jsonString, MovieListJsonModel.class);

The business model would look somewhat different:

public class MovieModel {
    public String title;
    public String id;
    public Uri imageUri;
    public Date releaseDate;
    public ArrayList<String> stars;

    // Just illustrating that the model can and should contain business logic, 
    // not only data.
    public boolean isReleased() {
        return releaseDate != null && releaseDate.before(new Date());
    }
}

(To create a list of this simply instantiate an ArrayList<MovieModel>.)

So here you see that many of the String-fields in the Transport Model have gotten a strong typed counterpart. The Date, The image URI and the comma separated list of stars is actually an ArrayList. I have not included the conversion code here but I'd advice to put it in the Transport Model class. This way you will not introduce a dependency from the Business Model to the transport protocol.

Finally an example of how a View Model could look:

public class MovieViewModel {
    public String title;
    public String releaseDate;
    public Bitmap image;
    public int backgroundColor;
    public boolean isSelected;
}

Here you can see that String-representation of the Date again. We want to control how a Java Date object is presented, and we do that when we create the View Model. Note that this also can be unit tested. Furthermore we have a Bitmap object for the image which earlier was represented with a URL. This of course requires us to actually load the image. I'm not so determined on where to place this loading code - either in the View Model or in the Business Model.

Finally there may be fields exclusively for the view, such as the backgroundColor here, or state properties such as isSelected. You may also have data from other Business Models, but I've not included that in this example.

Persisting the state

One of the key benefits of having a specialized View Model is when you're persisting the model for state preservation. You probably know that you need to do this in case the system kills the process or if you rotate the device. The Parceler framework makes this simple, but we do need to make some adjustments to the simplified example above to accommodate for the non-parcelable Bitmap object:

@Parcel
public class MovieViewModel {
    public String title;
    public String releaseDate;
    @Transient public Bitmap image; 
    public int backgroundColor;
    public boolean isSelected;

    // Reference properties:
    public String imageUrl;  

    // A service client for downloading images asynchronously w/Rx
    private ImageService mImageService; 
}

Now I've included the image URL as a String as well (Uri is not parcelable either). The code to load the image could be like this, using RxAndroid for callbacks (could also be implemented as a standard callback):

public Observable<Void> loadDataAsync() {
        if (image != null) return Observable.from(new Void[0]);
        else {
            Observable<Bitmap> imageObs = mImageService.loadImageAsync(movieModel.imageUri);
            Observable<Void> doneObs = imageObs
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1<Bitmap, Void>() {
                    @Override
                    public Void call(Bitmap bitmap) {
                        image = bitmap;
                        return null;
                    }
                });
            return doneObs;
        }
    }

The View, Fragment or Activity would then ensure the data is always loaded as illustrated in the onResume method here, while the onCreate ensure the View Model object is always instantiated:

public class MovieActivity
   private MovieViewModel mViewModel;

   @Override
   public void onCreate() {
       super.onCreate(Bundle savedInstanceState);
       if (savedInstanceState != null) {
           mViewModel = (MovieViewModel) savedInstanceState.getParcelable("ViewModel");
       }
   }

   @Override 
   public void onSaveInstanceState(Bundle outState) {
        outState.putParcelable("ViewModel", mViewModel);
        super.onSaveInstanceState(outState);
   }

   @Override
   public void onResume() {
       super.onResume();
        if (mViewModel != null) {
            loadAndBindViewModel();
        }
        else {
            // Load the models asynchronously from the REST Service, 
            // then call loadAndBindViewModel()
        }
    }

    private void loadAndBindViewModel() {    
       mViewModel.loadDataAsync().subscribe(new Action1<Void>() {
            @Override
            public void call(Void dummy) {
                modelToUi();
            }
        });
    }

    private void modelToUi() {
        // Map all View Model properties to actual view controls
    }

There might be cases where you want to persist the Business Model as well (or instead), like if you're doing local caching of the service data. In this case you probably do not want to store it in the Bundle attached to the Activity or Fragment though, but instead use Shared Preferences, Internal Storage or SqLite. I will not go into details about that in this post.

Summary

The "Model" term in MVP/MVC covers all types of Model representations I've touched upon here, but by sticking to the View Model representation you will separate the concerns of the transport, storage, business and presentation layer. Creating a separate View Model class will ensure you don't leak view-related stuff into the business layer, or transport-related fields into the business or view layer. Persisting the ViewModel class in the Bundle using Parceler will ensure that you retain the state of the view even after device rotations or process terminations.

Building a solid JSON REST client in Android using Volley, Gson and Otto

2014-06-08T03:07:00.002-07:00

Questions like "How do you make an HTTP request on Android" or "How do you do async/background JSON requests on Android", are question that often arise on Stack Overflow and blogged about elsewhere. Often the answers contain somewhat low-level code who leave a lot undecided for the developer. Firing an AsyncTask for the request to allow the processing to happen off the UI thread is good, but what if the UI element who fired the request is destryed when the response arrives? And what about parsing the resulting JSON? What about caching and throttling? These are questions that will be addressed in this post. A complete working project will provided at the end.

A word on Volley

Volley is a library by Google introduced at Google IO 2013 which set out to make REST client implementation simpler and faster. Unfortunately Google hasn't seemed to embrace their own project to the max, as it still is undocumented and no references to it seems to be found on developer.android.com. That doesn't stop it from being a powerful and effective library - enough blog posts exist about how to get started using it. This post goes a step further by introducing Gson for the simplest Json parsing. I also focus on 100% guarantee of any response being processed, which can be a challenge when dealing with Android activity lifecycles.

While most people would start out using AsyncTask for the request processing, Volley uses a thread pool of 4 threads by default. This has several advantages.

You don't need to spin up a thread each time a new request is sent. It's already there, waiting to serve you. Improves performance.
A limit of 4 ensures you don't congest the Android operating system while still allowing you for a fair amount of parallellism

If you do need more than 4 threads, you may download the Volley source code and tweak it yourself. If you need a lot more than 4 threads, you probably have a use case more suited for libraries like Ion. You can still apply most of the techniques in this blog post to that framework though.

In addition to this, Volley provides optional caching of GET-requests, primarily intended for image caching. You might want to look into that depending on your needs.

Gson instead of JsonObject

On top of Volley I'll be using Gson and an extension to the Request class allowing for seamless Json-response-to-Pojo-mapping. If you don't know what Gson is, it's a framework by Google allowing for automatic parsing and mapping of Json strings to plain java objects. Example:

Json:

{
        "age" : 14,
        "name": "ralph"
    }

Java class:

public class Person {
        public int age;
        public String name;
    }

This example uses fields, but you can use Java-bean properties if you prefer that (I don't).

The code to parse the Json to the object in this case would be a one-liner:

String jsonString = "{\"age\" : 14,\"name\": \"ralph\"}";
    Person person = new Gson().fromJson(jsonString, Person.class); // assuming jsonString contains the json above

Combining the power of Gson with Volley, we can make a GsonRequest-class which allows us to get a callback with the strongly typed object directly - never dealing with the intermediate parsing:

public class GsonRequest<T> extends Request<T> {
    private final Gson gson = new Gson();
    private final Class<T> clazz;
    private final Map<String, String> headers;
    private final Listener<T> listener;
    
    public GsonRequest(String url, Class<T> classType, Map<String, String> headers,
                       Listener<T> listener, ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        this.clazz = classType;
        this.headers = headers;
        this.listener = listener;
    }
    
    public GsonRequest(String url, Class<T> classType,
                       Listener<T> listener, ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        headers = null;
        this.clazz = classType;
        this.listener = listener;
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return headers != null ? headers : super.getHeaders();
    }

    @Override
    protected void deliverResponse(T response) {
        listener.onResponse(response);
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
            T parsedObject = gson.fromJson(json, clazz);
            return Response.success(parsedObject, HttpHeaderParser.parseCacheHeaders(response)); 
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e) {
            return Response.error(new ParseError(e));
        }
    }
}

Otto and the issue with device rotation and destroyed activities

I'm going to outline the following scenario of a poker game app for Android where a callback approach is uses for requests:

User opens the activity where he'll be presented with the cards dealt to him
The Activity fires the request to fetch the cards
The user realizes this view is best presented in landscape mode and rotates the device
Android kills the Activity which "owns" the request and creates a new one
The request completes and calls back to the now dead activity.
The dead activity is either smart enough to realize it's dead, so it discards the request, or it tries to process it and the application crashes when tryin to updated a dead UI.

This may sound as a far-fetched scenario or a rare edge case, but it is infact a real-life scenario I regularly encountered in production for a game I made.

The solution is based on introducing an Event Bus, also known as the Pub/Sub-Pattern. I've grown fond of the Otto library from Square Inc, which does a fine job at that. Instead of having callbacks to the Activity, we rely on a dispatcher to publish the response on the event bus once any response arrives. Whether or not it is the original or a new instance of the Activity then listening, is irrelevant.

Illustration of timeline when the user rotates the device before the response arrives

Now a second challenge arise because there is a small gap between the time where the old activity is killed and the new is created. Context switches might occur here, responses may arrive and be lost. To amend for this I have in addition made a class called OttoGsonResponseBuffer, which will receive and buffer any requsts arriving in this gap. This way we ensure that no response is ever lost when the user rotates the device right after a request is sent.

The response buffer handles responses arriving in the time gap where no activity lives

The way this functions is that Otto supports producing of events through the @Produce attribute, which will cause the response data to be resubmitted to the event bus once a new listener for that type of event subscribes.

A word of warning here: Be careful when you use this buffer with regards to memory use. There is no mechanism of timeout or automatic flushing of the buffer as it is implemented now. Do not activate the buffer when user presses the back button (or flush it after he does), only when rotating the device.

Source code

A complete working example and a proof of concept can be found at my OttoVolleyDoneRight github repo. It may also be used as a library by following the simple steps describe at the bottom of the README there.

When launching the example you are presented with a simple button labeled "HTTP Request", which will send off a request to http://httpbin.org/delay/1. This service always delays one second before responding, which allows you to test rotating the device while waiting. You can up the number 1 to whatever you like if 1 second is too short. Notice how the request is processed in the new activity instance after the device is done rotating and the response arrives.

Going further

The example provided here is a good start, but there are some properties you should be aware of which might not scale well or should be done different in your application, depending on your needs:

There is just one pair of HTTP resonse message-bus class defined: VolleyRequestSuccess/Failed. This means that you must check the type of response in the onHttpResponseReceived-methods of your listener classes. Due to type erasure in Java, you can only have one listener method in each class as it is now, and it will receive any kind of response.
The OttoGsonResponseBuffer doesn't autoflush. Potential memory leak. Be careful with where you place the
ResponseBuffer.startSaving()-method call.

In any case I believe this pattern provides a solid foundation for a JSON-based HTTP REST client for Android, and you'll have an application with fewer potential bugs than if you follow most other guides I've read so far online. Feel free to argue against me or come with suggestions for improvements in the comment below.

A comparison of Javascript IDEs

2013-12-20T04:32:00.001-08:00

Jump to results

Motivation

I am primarily a developer of .NET, but lately I've been working more and more with Javascript and HTML5. Like many of my readers who've also primarily been working with static languages like C# and Java, I also see the trend of applications previously only viable to develop in a compiled language, now being developed with web technology. The browser support of HTML5, Javascript and CSS3 is now very good across the board, so much that I'm tempted to call it mature. When it comes to tooling though, I've been surprised more than once to see professional developers speaking at conferences bringing up their solution in what I presumed was simple text editors such as Sublime Text or Notepad++. Not that there's anything wrong with those editors, its just that they are just that: Editors. Not IDEs: Integrated Development Environments - products that have a birds eye perspective on your solution as a whole and aids you in crafting great applications as apposed to files.

So was I wrong? There were three options:

Sublime Text has actually become a fully fledged IDE
Sublime Text is the state of the art of Javascript editors, although not on par with IDE's for static languages.
The speakers aren't using the best tool available.

I decided to find out which of the three was true, and the result I present to you in this blog.

Scope

What I've done in this test is to gather a number of criteria I believe are essential in a modern IDE for effective programming. The criteria I bring with me from years of experience of using tools such as Visual Studio and Eclipse developing C# and Java. The criterias may not be exactly ties of the IDE/editor. The criteria I then tested on a range of IDE's which I believed were good developing Javascript, and editors I've seen others praise as good IDEs.

1) If you feel I've left out some important criteria or editors, feel free to comment on this blog, and I'll consider compiling a version 2.

The criteria

Here is the list of criteria I tested:

1. Intellisense / auto-complete

Is the editor capable of providing typing hints both on framework and self-coded functions? Will it provide parameter info on all functions? Even on functions in other files? This is an important feature both because it helps on typing speed, but more importantly it reminds you what the signature of any function is. It will save you a lot of Googling (framework functions) and solution2 navigation (own functions). This is a major time-saver when properly implemented.

2) I use the term solution as meaning a set of HTML, Javascript, CSS and content files which have some sort of interdependency, and together form an application.

Intellisense on a framework function in Netbeans

2. Solution navigation

Go to definition: When the signature of the function is not enough and you want to view (or edit) the contents of the function, a quick way to navigate to the function call you're looking at is useful. This should be a one-keystroke shortcut from anywhere in the solution. This also goes for variables, as it for instance can be useful to see the initialization code of the variable.

Find usages: (Aka "Find references") Could be used to navigate to a concrete usage which you don't remember exactly where was, or it could be used to determine what the impact of a change of this function will have. Not in terms of renaming the function, because refactoring should take care of that, but for changing behavior.

Navigate to file: When the cursor is on the "href" or "src" part of a script- or stylesheet-tag, you should be able to navigate to that file with a single key press.

3. Refactor: Rename

Of all the refactoring functions, this is the one I use most often. This is the only one I'm truly dependent on. I utilize and appreciate others, but if the IDE doesn't have support for solution-wide renaming, you're in trouble. Most likely you'll often end up with sticking with original names of all functions and variables as the program evolves, because of the hassle of changing names. But behavior and meaning of functions change. So should names. There's nothing I hate more than finding a code base with the function getDollarValue only to find it accepts a parameter for an arbitrary currency.

4. Code outline view

I find it useful to have a quick overview of a file or class in a window pane next to the code itself. It quickly gives you an indication of the size of the file, it's role and concerns. It helps you keep the architecture clean and the code tight, in addition to be a navigational aid.

The Navigator pane in Netbeans

5. Syntax error highlighting

In a parsed language this is even more important than in a compiled one. Why should I have to waste time running the application and checking the console view only to find out I forgot a semicolon?

Syntax error hint in Visual Studio 2013

Debugging (not included)

Some of the IDEs have debugging capabilities. I haven't considered this feature essential because all the majors browsers have this now so you might as well use the browser for debugging. For those who have it though (All but Sublime), it might be better to use the IDE-debugger for convenience.

The editors

Visual Studio 2013

Visual Studio from Microsoft should be well known from anyone coming from a C++ or .NET-world. It's a monster of an IDE both in terms of size and list of features. In the later years Microsoft have had great focus on improving the support for Web technology, including Javascript. They're not quite there yet but they're getting there.

Visual Studio 2013 + #Resharper

If you purchase Jetbrains' Resharper-plugin for Visual Studio, you're getting all the coding support you need and more. It's going to cost you though - not only the license cost of Resharper (~$150 for a personal license), but you're not getting away with the Express edition of Visual Studio anymore either.

WebStorm

Jetbrains is not only developing VS-plugins. They have their own IDE(s). WebStorm's Javascript support is nothing short of superb. The sister-product PhpStorm also adds support for the PHP language, if you're into that.

Eclipse

One can't write a review of an IDE of any language without mentioning Eclipse. I was actually quite impressed with the Javascript features you get for free (as in beer) from this IDE. It doesn't come for free in regards of man-hours though. First you need to install the Javascript Developer Tools plug-in, then you have to configure the key bindings for the functions you'll need, and then - if you're lucky - you may start being productive (I wasn't that lucky).

Sublime Text 3 + SublimeCodeIntel (ST3+SCI)

Sublime Text 3 (ST3) is a very sleek and good looking editor with a lot of nifty features you don't find anywhere else. But is it an IDE? Everywhere when the discussion of Javascript editing in ST3 comes up, the add-in SublimeCodeIntel is mentioned in the next sentence. This package will give you Javascript intellisense and some navigational functions and blurs the line between an editor and an IDE.

Cloud9

Cloud9 is stands out in the crowd as the only web-based IDE. I saw it mentioned in a closed question on Stack Overflow addressing the same question as I do in this blog post. I must admit I was highly skeptical to a web-based IDE and didn't have very high expectations going in. But I was surprised and impressed how far they have come. They have It still doesn't quite make it to elite league of IDEs, but I'll be following the development of this and similar services keenly in the years to come.

Google Chrome

Wait a second, you say.. Isn't that a browser? You're including both text editors and browsers in this test? Yes I do. Because people are starting to claim that Chrome is an IDE. I wanted to test if that claim held up. From my results you'll see that it didn't. It's a great Javascript debugger and on-the-fly hack-tool, but it's not an IDE. Yet.

vim (not included)

Vim is not included in this test. Many developers use Vim sort of as an IDE (comparable to Sublime Text 3) and would probably like me to include it. I didn't do that primarily because I don't have the time to get to know Vim and its plugins well enough to be able to answer all the questions. From what I've read, you should be able to get some Code hints (intellisense) and also a Tag list which acts like a Code outline view. Refactoring support is absent as far as I can tell.

I don't believe anyone should switch to Vim solely because they're looking for a good Javascript IDE. There might be many good reasons to learn Vim, but as far as Javascript IDE's goes, it's not the best as of today. I know it's an editor - not an IDE, but the same goes for Sublime Text 3. Yet these lines seem to blur.

The result matrix

So here are the results, after hours of installing, configuring and testing code in the different IDE's:

Feature\IDE	VS2013VS	VS2013+R#VS+ R#	WebStormWS	NetbeansNb	EclipseEc	ST3+SCIST3	Cloud9C9	ChromeCh
1. Intellisense
a) DOM functions	Y	Y	Y	Y	Y	Y	Y	N
b) Own functions/variables	*	Y	Y	Y	*	Y	*	*
c) ...showing parameter list	Y	Y	Y	Y	Y	Y	*	N
d) File references (src, href)	N	Y	Y	Y	N	N	N	N
2. Navigation
a) Go to declaration	*	Y	Y	Y	*	Y	*	N
b) Navigate to file (src, href)	N	Y	Y	Y	*	N	N	N
c) Find usages	N	Y	Y	N	Y	N	N	N
3. Refactor: Rename
a) Functions	N	Y	Y	*	Y1	N	Y	N
b) Variables	N	Y	Y	*	Y2	N	Y	N
4. Outline*view	N	Y	Y	Y	Y	N	N	N
5. Syntax error highlighting	N	Y	Y	Y	Y	N	Y	N

*) Only within the scope of a single file. Not solution-wide.

1) Icouldn't get this to work, but it's supposed to work

2) Only when using the "var"-keyword in front. When in form "mylib.someVar", it does not work.

Please leave a comment if you find any errors in the table.

Conclusion

I was pleasantly surprised on how good the Javascript support were in many of the IDEs I hadn't tested previously. I was similarly disappointed with Visual Studio 2013 out of the box, which I thought had better support after hearing talks from Microsoft-guys the later years on the focus on web technology for their IDE. Sublime Text 3 performed as expected - it's good for quick editing of small projects, but it won't hold up for larger project against the other guys.

I won't name a single IDE as the best - I haven't tested them all well enough for that. But if you are developing large Javascript applications, you won't go wrong with either VS2013 with Resharper, Netbeans, WebStorm or Eclipse. I guess it depends more on what you're used to, what your project manager offers or what your wallet can afford.

As for the question coined in the "motivation" section - I'd say it's a clear #3, given the question was "best tool for developing Javascript solutions". I do understand that in a presentation context, other factors may come to play. In short: choose whatever tool you like, but please make a consious and educated decision! I hope this article have contributed in educating you just a little bit.

Pushing from Mercurial to an empty, non-bare Git repo on Windows

2013-12-19T03:45:00.000-08:00

Today there's good, 2-way integration between Git and Mercurial. Git has hg-git which is an extension that allows you to clone, push and pull git repos. Likewise Git has git-remote-hg for interacting with Mercurial-repos. Both of these extension come pre-compiled with the git and hg-installations I'm using on Windows, so getting them to work was simply a matter of configuration.

What wasn't that simple though, was getting the first push through. I had an empty repo at Visual Studio Online which I wanted to populate with the check-in history of my Mercurial repo. I met obstacles because non-bare Git repo's doesn't appreciate being pushed to by Mercurial. See this article on bare vs non-bare repos for more info. So then I tried pulling from git instead, but that was equally challenging because I needed Python-support in Git for the git-remote-hg extension to work. Apparently that is not supported in Windows.

Solution: Create an intermediary bare git-repo.

So, here's the receipe of command you need to execute in order to complete the conversion. I'm not including the CD-commands - the foledr you need to be in is indicated on each line. Assumptions:

HgSource is the source repository with a history
GitTarget is the empty, non-bare git-repo you want to push to
c:\GitTempTarget is simply an empty Windows folder

c:\GitTarget> git config --local receive.denyCurrentBranch warn
 c:\GitTempTarget> git --bare init
 c:\HgSource> hg push c:\GitTempTarget
 c:\HgGitTempTarget> git push c:\GitTarget master
 c:\HgGitTarget> git config --local --unset receive.denyCurrentBranch

Note: This is a one-time conversion of the repository. I have tried pushing consecutive changesets from HgSource directly to HgGitTarget without success. If anyone know how to achieve that, please drop a comment below.

Configuring an "I feel lucky" search shortcut in Chrome

2013-12-07T03:42:00.001-08:00

I normally blog about programming stuff, but this is just one of those "superuser life pro tips" that I feel I have to preach to the world. You know those times when you need refreshed how to do Padding with String Format and you just know you're gonna click the top result? Or the argument list of PHP strstr, that stinking DateTime parsing in Java? Or, or or...

The "I feel lucky"-function has been around for years, but it's really not effective. You have to 1. Go to www.google.com, 2. type the search text, 3. move the mouse over to the "I feel lucky" link and click. No one goes to google.com anymore anyways, right? You just type in the search address bar, or "omnibox" as it's called in Chrome. But you're still forced to do two moves because you have to see the results first. That of course is not by accident. But we're programmers. We work around stuff :-)

Hence I present you the Google I-Feel-Luck "search engine". It's not rocket science, but I had to Google it to get the answer (Thank you timmmy_42). This is how to do it in Chrome (but I guess there's equivalents in both IE, Firefox and Opera):

Open Settings
Click on Manage Search Engines
Create a new entry with the following parameters:

Search engine:	"Google Lucky" (or other name of your choice)
Keyword	"l" (or other short keyword of your choice)
URL	https://www.google.com/search?q=%s&btnI

Voila! You may now perform an "I feel lucky" search in chrome by prefixing your search with the letter L in the omnibox. Example:

Click enter:

edit: I've noticed that Google doesn't always bring you directly to the result even if you do include the Im-feeling-lucky query parameter (the Java example in my post for instance). If anyone can find a pattern in when this happens, I'd be glad to learn more about this.

101 LINQ Samples Lambda style

2013-05-19T13:01:00.003-07:00

I have many times had use for the 101 LINQ samples by Microsoft when needing to refresh how to do different kind of queries in with Linq. Often I prefer to have them expressed in Lambda or "fluent" syntax instead of query syntax though, so it has always bothered me that they haven't published them in both formats. Luckily there are tools that allow you to automate conversion between the two formats. I used Resharper by Jetbrains to perform the conversion semi-automatically and have now published all 101*) examples for you in lambda/fluent syntax.

*) Actually there are 102, but hey :)

Head over to linq101.nilzorblog.com to see the result.

Download source (VS2010 project): linq101-lambda-source.zip

A HelloWorld-example of a Jersey REST service hosted at Google AppEngine

2013-02-11T03:01:00.000-08:00

In this short tutorial I will outline the project setup and deployment steps needed to get a Jersey REST-application up and running at Google AppEngine. There are a couple of non-intuitive issues that got me struggling for days - hopefully you won't have to do the same.

1. Environment and AppEngine installation

I will be using the following IDE, framework and SDK versions in this example. Installation of these are out of the scope of this post but I will provide a couple of links:

Java Development Kit (JDK) 1.6 SE
JDK 1.7 is not fully supported by AppEngine
AppEngine SDK v1.7.4
Eclipse Juno EE

After installing the AppEngine SDK and the plugin for Eclipse you shall have the Google Toolbar available as well. Use this as a verification that you're done with the installation phase.

2. Project setup

Go to File > New > Other... (or Ctrl+N) and select Google > Web Application Project

Give your project a name and a namespace and unselect "Use Google Web Toolkit", as we won't have any UI in our application. Also uncheck "Generate project sample code".

Now go to Project Properties (Alt+Enter while focusing on the project root in the Project Explorer) and go to Google > App Engine. Select v1 of Datanucleus JDO/JPA version. This is because using v2 will generate a dependency conflict on the file version of asm*.jar which Jersey also depends on.

Now copy all of the following jar files from the Jersey home page into your /war/WEB-INF/lib folder:

JAR file	Role
jersey-bundle-1.17.jar	Core Jersey Server components
jettison-1.1.jar
activation-1.1.1.jar	POJO-to-JSON object mapping support
jackson-core-asl-1.9.2.jar
jackson-jaxrs-1.9.2.jar
jackson-mapper-asl-1.9.2.jar
jaxb-api-2.2.4.jar
jaxb-impl-2.2.4-1.jar
stax-api-1.0-2.jar
jackson-xc-1.9.11.jar	Allows you to use JAXB annotations and rids of an initial exception if you don't

JAR file

Role

jersey-bundle-1.17.jar

Core Jersey Server components

jettison-1.1.jar

activation-1.1.1.jar

POJO-to-JSON object mapping support

jackson-core-asl-1.9.2.jar

jackson-jaxrs-1.9.2.jar

jackson-mapper-asl-1.9.2.jar

jaxb-api-2.2.4.jar

jaxb-impl-2.2.4-1.jar

stax-api-1.0-2.jar

jackson-xc-1.9.11.jar

Allows you to use JAXB annotations and rids of an initial exception if you don't

Note that the links from the Jersey.java.net-page always links to the newest version of Jersey. I can only guarantee that this tutorial works with the exact specified versions of the jar's.

Remove asm-4.0.jar from the lib-folder. Note that you have asm-3.3.1.jar there instead.

Finally right click on jersey-bundle-1.17.jar and select Build Path > Add to build path

3. Implementing a Hello world method

Add a new class HelloWorldObject to the namespace "com.example" or whatever namespace you chose for your project. Let the conent of that class be the following:

public class HelloWorldObject {
 public String text = "Hello world";
}

Add a new class HelloWorldApi to the same namespace. Let it contain this:

import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.Produces;
 import javax.ws.rs.core.MediaType;

 @Path("/hello")
 public class HelloWorldApi {
  @GET
  @Produces(MediaType.APPLICATION_JSON)
  public HelloWorldObject getHelloWorld() {
   return new HelloWorldObject();
  }
 }

Edit the file /war/WEB-INF/web.xml. Add a new servlet definition "HelloWorldServlet":

<?xml version="1.0" (...)>  
 <servlet>
  <description>Hello World Service</description>
  <servlet-name>HelloWorldServlet</servlet-name>
  <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
  <init-param>
   <param-name>com.sun.jersey.config.property.packages</param-name>
   <param-value>nilsnett.chinese.backend</param-value>
  </init-param>
  <init-param>
   <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
   <param-value>true</param-value>
  </init-param>
  <init-param>
   <param-name>com.sun.jersey.config.feature.DisableWADL</param-name>
   <param-value>true</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>HelloWorldServlet</servlet-name>
  <url-pattern>/api/*</url-pattern>
 </servlet-mapping>

 <servlet>
  <servlet-name>SystemServiceServlet</servlet-name>
  <servlet-class>com.google.api.server.spi.SystemServiceServlet</servlet-class>
  <init-param>
   <param-name>services</param-name>
   <param-value />
  </init-param>
 </servlet>
 <servlet-mapping>
  <servlet-name>SystemServiceServlet</servlet-name>
  <url-pattern>/_ah/spi/*</url-pattern>
 </servlet-mapping>
</web-app>

A couple of notes:

The POJOMappingFeature-param is the one enabling support for returning standard Java objects directly from an API method which then gets serialized to JSON behind the scenes using Jackson. See the Jackson documentation on how to tweak the output generated here.
The DisableWADL-parameter disables use of reflection, which is banned at Google App Engine.
I'm leaving the SystemServiceServlet as it is. You might not need this though.

4. Deployment

The deployment part couldn't be easier. Right click on the project root in the Project Explorer, click Google > Deploy to App Engine. If you haven't already, you'll be guided into the App Engine project settings in order to set your Application ID. When that is done and if everything goes well, you should have the service available in about 30 seconds.

5. Testing and further reading

Finally it's time to test the service. The url will be http://yourAppEngineDomain.appspot.com/api/hello. The output should be like this in Chrome:

From this point on, the fun part starts. If you're new to Jersey I a good starting point is to read . A good starting point is the REST with Java (JAX-RS) using Jersey Tutorial by Lars Vogel. That post contains a lot of setup information that is irrelevant for Google AppEngine though, but chapter 2.2 JAX-RS annotations, and the example in chapter 7.3 Rest Service are still very relevant.

Jersey vs Google Cloud Endpoints as REST-service at Google AppEngine

2013-02-09T08:20:00.000-08:00

Last week I wrote about how to use Google Cloud Endpoints (or "Endpoints" for short) to create a JSON-producing REST-service at Google App Engine. This week I will present an alternate approach, using the Jersey REST framework with JSON POJO support. In this post I will discuss the rationale as to why, while in the next post I will describe how.

So why do we need another approach? Why not use Google's own REST implementation instead of pushing extra jar's to AppEngine bloating the solution? Well the implementations are different of course and I can think of several reasons to choose Jersey over Google Clound Endpoints:

Google Endpoints is still in beta

Google themselves don't recommend you using Endpoints in production systems yet. This should be reason enough. The poor documentation and error messages in the framework are others.
Better flexibility

The Endpoints framework enforces a strict RESTful architecture. Although you may view this as a good thing, most real-world "REST services" today diverge to some extent from the true RESTful principles as outlined by the Godfather of REST himself, Roy Fielding in this blog post. A simpler, pragmatic approach to REST is not necessarily a bad thing though.
Better portability

By using a third-party API for endpoint-generation you will have a smoother ride if you at any point need to migrate to a different platform than Google AppEngine.

The kicker for me was the flexibility. The true RESTful architecture leaves no room for business logic on the server. All operations must be dumb CRUD-operations. While this results in a highly scalable architecture, it's not one fitted for all back-end scenarios. If you want to create a RPC-service based on JSON over HTTP* (is there a name for this?), you need a framework that allows you to define the input and output types arbitrarily and map them to the HTTP verbs as you wish. Google Endpoints does not that. In short, these two restrictions are the one causing trouble (or consitency, depending on your point of view=:

Update 11th feb 2013: See last paragraph with an update that refutes this "kicker".

*If you do this, be careful not to call it a "REST Service", as Roy Fielding will hunt you down for public scalding.

The URI will be named after the class name of the return type
If you have a complex object as input (POJO), the output must be of same type

What if you want to create an advanced search routine which takes a filter object as input and returns the list of entities as output? In Jersey you can do that the following way:

@Path("/api-base/user")
 public class User {
  @POST
  @Produces(MediaType.APPLICATION_JSON)
  @Consumes(MediaType.APPLICATION_JSON)
  public ArrayList searchUsers(UserFilter filter) {    
   ArrayList users = new ArrayList();
   // Populate users through search logic
   return users;
  }
 }
 
 public class UserFilter {
  public String text;
  public String zipCode;
  public String maxAge;
 }

You would then use this search function by doing an HTTP POST to http://host/api-base/user where the POST payload is a JSON representation of the UserFilter object, e.g. { "text" : "roger" }

If we try to do the same with Endpoints we need to adhere to rule #2 mentioned above, and thus we'll be unable to take a UserFilter object as input while returning ArrayList<user>. We could get around it by creating a parameter for each of the optional filter parameters, but this would force the consumer to always pass something for these values as the Endpoints framework would produce a 404-error otherwise:

@Api(name = "api-base")
 public class Api {
  public ArrayList getUsers(@Named String text, @Named String zipCode, @Named String maxAge) {    
   ArrayList users = new ArrayList();
   // Populate users through search logic
   return users;
  }
 }

To use this you would then to a HTTP GET to http://host/api-base/user/TEXT/ZIP/MAXAGE where the uppercase-text in that URL are the parameter values. This is not very flexible as you need to pass all parameters always.

Summary

I'm aware this is a superficial and subjective comparison of the two frameworks. There are a lot of other factors that I haven't considered, like performance and security. I do believe I've highlighted the main differences from a developer's and architect's point of view though - and if nothing else I hope to get feedback and counter-arguments to my points.

Finally I'd like to underline that the Google Cloud Endpoints framework still is in Beta, and that all my arguments in this post may be void tomorrow. This is the state of the framework as of today though, and I hope my post can help people make the right decision when it comes to framework for REST-ish services at AppEngine.

Update 11th feb 2013:.

I had not read the documentation well enough. There is indeed full flexibility when it comes to URL generation and input-output-class types with Google Endpoints - Good news! Thanks to Dan Holevoet from Google pointing this out in the comments.

Implementing the search example above using Google Endpoints is done like this:

@Api(name = "api-base")
 public class Api {
  @ApiMethod(httpMethod = "POST", path = "searchUsers")
  public ArrayList getUsers(UserFilter filter) {    
   ArrayList users = new ArrayList();
   // Populate users through search logic
   return users;
  }
 }

Or you could implement it with optional GET-parameters this way:

@Api(name = "api-base")
 public class Api {
  @ApiMethod(httpMethod = "GET", path = "searchUsers")
  public ArrayList getUsers(@Named("text") String text, @Named("zipCode") String zipCode, @Named("maxAge") String maxAge) {    
   ArrayList users = new ArrayList();
   // Populate users through search logic
   return users;
  }
 }

A Google Cloud Endpoints Hello-World example in Java using Eclipse

2013-02-05T12:00:00.000-08:00

Introduction

For the last couple of days I've been working to get a simple REST service up and running at Google AppEngine using the Google Cloud Endpoints framework presented at Google IO 2012. The introduction at the page just linked to in addition to the documentation gave the impression that this was a very simple and straight forward framework to use. It might be, but I still used three days to get a hello world application up and running. The reason for this is compound. I may be an idiot, but I will also put part of the blame on an incomplete documentation by Google. The Google Cloud Endpoints techonology ("Endpoints" from now) is still only in semi-closed beta though, so I should probably not expect more. In any case, I am writing this blog post so that others will only use the single hour needed to get a hello world app up and running instead of the full three days* I used.

*) Some of this time was spent testing other PaaS REST technologies as well as waiting for answers on forum posts, but still...

Access, installation and environment

The Endpoints technology is available for all to use - you do not need to join the trusted testers group other than for getting access to the documentation. You should still of course do this. I will also refer to this documentation in this post. I'm just saying that the framework is indeed embedded in the AppEngine SDK v1.7 which I am using.

I will be using the following IDE, framework and SDK versions in this example. Installation of these are out of the scope of this post but I will provide a couple of links:

Java Development Kit (JDK) 1.6 SE
JDK 1.7 is not fully supported by AppEngine
AppEngine SDK v1.7.4
Eclipse Juno EE

After installing the AppEngine SDK and the plugin for Eclipse you shall have the Google Toolbar available as well. Use this as a verification that you're done with the installation phase.

Creating the project

Go to File > New other or hit Ctrl+N in Eclipse. Select Google > Web Application Project.
Enter a project name, a package name and uncheck the use of Google Web Toolkit which is a GUI framework we won't be needing for a back-end solution. I will be using "com.example" as package name in this example. Whenever I refer to this package name later, replace with your.
Delete /src/com.example/HelloWorldServlet.java and /war/index.html as we will not be using these.

Create a new class /src/com.example/HelloWorldEndpoint.java. Let the content be the following:

package com.example;

    import com.google.api.server.spi.config.Api;

    @Api(name = "example")
    public class HelloWorldEndpoint {
     public Container getThing() {
      Container c = new Container();
      c.Text = "Hello world!";
      return c;
     }
     
     public class Container {
      public String Text;
     }
    }

Edit /war/WEB-INF/web.xml and set the init-param SystemServiceServlet to point to HelloWorldEndpoint instead of HelloWorldServlet. You can delete the HelloWorld-servlet definition entierly, leaving the final web.xml to look like this (namespaces in web-app tag removed for brevity):


    
     
      SystemServiceServlet
      com.google.api.server.spi.SystemServiceServlet
      
       servicescom.example.HelloWorldEndpoint
     
     
      SystemServiceServlet
      /_ah/spi/*

Testing

Launch your app by selecting Run > Run while for instance HelloWorldEndpoint.Java file is open. Jetty Application Server will launch and the Console in Eclipse will display a bunch of output. One of the final lines should be this, which indicates you're good to go:

INFO: The admin console is running at http://localhost:8888/_ah/admin

Your port may vary from 8888. Use this info to launch a web browser at the following URL, replacing 8888 with whatever port your server is running at:

http://localhost:8888/_ah/api/example/v1/container

The result should be the following:

How URL's are generated

UPDATE 11th Feb 2013: The following section was written without knowledge of the path and httpMethod-parameters of the @ApiMethod annotation. See the documentation. While the below is still true, it's far less important to know how URL's are generated because you're not bound to it.

Now this is the part that got me. The official Google Cloud Endpoint documentation for Java (as per February 5th 2013) does not specify in detail how the URL's are generated. Instead it encourages you to go ahead and create the client libraries and consume the service that way. While that is the end goal for me as well, I like to know the intermediate steps so that I can debug better and possibly open up for creating clients not supported by the client-code-generating library, like Windows Phone.

The URL's to access your services in a HTTP REST-manner*** is generated in a combination of class/method annotation and code convention. This is the general rule from the point of view of a URL:

http://host:port/ServiceRoot/ApiName/Version/Entity/param1/param2/paramN

Keyword	Maps to
ServiceRoot	As configured in <url-pattern> of the servlet mapping in web.xml
ApiName	The name-parameter of the @Api annotation of the class mapped in services class in web.xml (API-class from now).
Version	The version parameter of the @Api annotation of the class mapped in services class in web.xml. (Default: "v1")
Entity	The class name in lowercase which an API method returns - except for remove-methods, where it's taken from the postfix of the method name (sigh...)
Param1/2/N	(Optional) Value of the N'th @Named annotation of any method parameter of type String or int

Keyword

Maps to

ServiceRoot

As configured in <url-pattern> of the servlet mapping in web.xml

ApiName

The name-parameter of the @Api annotation of the class mapped in services class in web.xml (API-class from now).

Version

The version parameter of the @Api annotation of the class mapped in services class in web.xml. (Default: "v1")

Entity

The class name in lowercase which an API method returns - except for remove-methods, where it's taken from the postfix of the method name (sigh...)

Param1/2/N

(Optional) Value of the N'th @Named annotation of any method parameter of type String or int

***) The framework also generates endpoints accessible through some HTTP RPC URL-convention, which I don't know how works. Feedback on this appreciated.

In addition to this, the prefix of any method name in the API-class will determine to which HTTP request method it will respond. The full table of these prefixes, from my knowledge is:

Prefix	HTTP method	Return constraint	Input constraint
get	GET	Any class T	None or any number of @Named parameter of type String/int
list	GET	T[] or List<T>	None or any number of @Named parameter of type String/int
insert	POST	Any class T1	One class T2**** and any number of @Named parameter of type String/int
update	PUT	Any class T1	One class T2 and any number of @Named parameter of type String/int
remove	DELETE	Any class T	None or any number of @Named parameter of type String/int

Prefix

HTTP method

Return constraint

Input constraint

get

GET

Any class T

None or any number of @Named parameter of type String/int

list

GET

T[] or List<T>

None or any number of @Named parameter of type String/int

insert

POST

Any class T1

One class T2**** and any number of @Named parameter of type String/int

update

PUT

Any class T1

One class T2 and any number of @Named parameter of type String/int

remove

DELETE

Any class T

None or any number of @Named parameter of type String/int

****) Should, but need not, be equal to type T1

In all of the examples, class T is typically any business entity class. It cannot be System.String.

Just to summarize and underline some of the facts I've deduced from these rules and from experimenting:

The framework relies heavily on reflection and code convention to find out which methods to expose and how
You do not need to annotate any methods, although the @ApiMethod can be used for convenience (see client library generation)
All parameters must be annotaded with @Named.
If you break any of these rules the framework will give you a 404 error without any further explanation.

A couple of examples:

1. From the hellow world-example with one get-method, this is how the framework maps it to a URL:

CODE

URL

HTTP GET http://localhost:8888/_ah/api/example/v1/container

2. An insert method with GET-parameter in addition to object payload

CODE

URL

HTTP POST http://localhost:8888/_ah/api/example/v2/container/4381294

3. Remove method

CODE

URL

HTTP DELETE http://localhost:8888/_ah/api/example/v1/container/4381294

No it's not a mistake that I've now red-boxed the method postfix "Container" in "removeContainer". The remove method does not follow the same code convention as the others. Thank you Google. I sincerely hope this is a bug.

Troubleshooting

Finally I'd like to mention a couple of pointers as to where to look if you can't make this work. These are pitfalls I've gone into. So, in no particular order:

Look for errors messages in the Jetty error console
Make sure war/WEB-INF/yourapname-v1.api is autogenerated after each compilation. Try removing the @Named-annotation in front of a random input parameter for a method. You will notice that the .api file is not generated. This will result in all of your methods returning 404-errors.
Make sure you always shut down the server before launching a new version on the dev-server. Or else your old code is still running and serving. See illustration:

Final words

I really like the idea of Google pushing their own REST framework for AppEngine. It eliminates one source of dependency problems which frameworks like Jersey and RESTlet gives you. What I don't like is the poor documentation and the inconsequent code convention. I guess that's what you get for working with beta software. Just be cautious pushing any code to production knowing this. I'm still going to use this as back-end for my Android software. Solely for the reason that this is the only REST-framwork I've gotten to run on AppEngine. I even went so far as to try Microsoft Azure for Java in desperation, but more on that in another post ;-)

Improving the Generic C# Dictionary with extension methods

2013-01-08T07:30:00.000-08:00

The Generic Dictionary in C#/.NET is very versatile and I use it a lot. So often that I found myself writing the same pattern of code around them over and over again. Code I feel should be a part of the class itself. Therefore I've taken the liberty of writing a couple of short extension methods that I really think would help clean up and make your code more readable whenever you're using Dictionaries. Speaking of readability - It's important to understand your own code.

The first pattern I often encounter, is checking whether or not a key exists in the dictionary before attempting to retrieve the value. As we know, the dictionary throws an exception if the key does not exist. Yes, I know there is TryGetValue-method, but then you have to meddle with out-parameters and your get-code is already more than one line. The extension method GetOrDefault below aims at solving this. Instead of throwing an exception when the key is not present, it returns the default value of that class.

The second pattern I often use is also related to non-existent keys. But this time I want to construct a new object if it doesn't exist, and work with this new object in the code lines to come. There is an elegant solution to this as well using generics, although it will require the value type to be of a class type. See method GetOrInsertNew below on how I solved that in four lines.

Here is the complete class:

public static class DictionaryExtensions
    {
        /// <summary>
        /// Returns the default value of type U if the key does not exist in the dictionary
        /// </summary>
        public static U GetOrDefault<T, U>(this Dictionary<T, U> dic, T key)
        {
            if (dic.ContainsKey(key)) return dic[key];
            return default(U);
        }

        /// <summary>
        /// Returns an existing value U for key T, or creates a new instance of type U using the default constructor, 
        /// adds it to the dictionary and returns it.
        /// </summary>
        public static U GetOrInsertNew<T, U>(this Dictionary<T, U> dic, T key)
            where U : new()
        {
            if (dic.ContainsKey(key)) return dic[key];
            U newObj = new U();
            dic[key] = newObj;
            return newObj;
        }
    }

As an example of how using this improves the readability of your code, let's say you're building some kind of custom session handling for some sort of service. Using plain Dictionary without the extension, you could implement the GetSession-method like this:

private Dictionary<string, Session> _sessionDic; 

    public Session GetSession(string sessionId)
    {
        if (_sessionDic.ContainsKey(sessionId)) return _sessionDic[sessionId];
        var session = new Session();
        _sessionDic[sessionId] = session;
        return session;
    }

Now using the extension methods, the retrieving code could be reduced to one line:

private Dictionary<string, Session> _sessionDic; 

    public Session GetSession(string sessionId)
    {
        return _sessionDic.GetOrInsertNew(sessionId);
    }

Another convenience is that if you are like me and work with other languages that are dynamically typed, like Javascript or PHP, the Dictionary will now behave more like their counterparts Associative arrays in Javascript and Arrays in PHP. (Yes I know they're far from exactly the same, but they have comparable behaviour)

In summary, this is no sorcery - just a simple tool that I have found to be nice to have in my toolbox, and what I believe to be a good application of extension methods.

Update 11th Feb 2013:

Simen's suggestion from the comments is implemented and posted to this public github gist

Lessons learned from my first Windows 8 Metro development project

2012-10-18T02:30:00.002-07:00

Yesterday I talked at NNUG Oslo about my experiences and lessons learned developing my first Windows 8 application Ticki. Coming from a .NET WinForms world, the things that took the most time getting a grip on was the new pattern for asynchronous programming using async await and the Task Asynchronous Pattern. An other challenge for me was doing MVVM right. I knew the gist of the pattern, but applying it correctly in a Windows 8 context took some learning.

As promised, I leave you here with a link to the slides and also a summary of the resources I link to from that presentation:

On asynchronous programming

Lucian Wishik's talk from NDC 2012: Part 1, Part 2
Stephen Toubs Task Asynchronous Pattern (TAP) paper
The Async Semaphore class by Stephen Toub. (Check out more of his posts, for instance his async-await FAQ, when you're there!)

On MVVM and Databinding

The MVVM Pattern from Microsoft Patterns and Practices
The MVVM Light Toolkit. Note: You can also install this via NuGet with "Install-Package MvvmLight"
Achieving Databound Visual States in Windows 8 Metro apps.
More on Attached Properties

Creating user controls and getting to know the UI framework

Scott Guthrie on Control Templates
The Visual Tree vs the Logical Tree from Josh Smith at Codeproject.com
Creating Custom dependency properties (MSDN)

And finally, the slides:
Ticki-Erfaringer-NNUG-Frode-Nilsen.pptx

Using wget to call WCF services

2012-05-04T07:16:00.004-07:00

There are a number of general purpose tools created to perform calls to WCF services, like SoapUI and WCFStorm. Visual Studio also ships with one - WcfTestClient, but this one is very simple and has no features for automation. Some times you just want to perform a low level call, or you want to make WCF-calls from a BAT/CMD file. Why download and install a multi-megabyte packaget when this should be as simple as performing a fairly standard HTTP GET request?

wget is a utility that should be in any web developer's tool box. If you're on linux this is a no-brainer (apt-get install wget), but you can also get this on windows. Heard of gnuwin32? You can use the download manager getgnuwin32 to get the entire package, or you can just download what's needed for wget. If not, make sure you download both the binaries and the dependencies zip file.

Using BasicHttpBinding (SOAP 1.1)

As an example, let's say you've created the following service

    [ServiceContract(Namespace = "http://tepmuri.org/myservice/")]
    public interface IService
    {
        [OperationContract]
        string Hello(string name);
    }

    public class Service : IService
    {
        public string Hello(string name)
        {
            return "Hello " + name;
        }
    }

It's a simple Hello World service that takes a string for input and returns one as output. Let's also make the following assumptions:

You're serving it at http://localhost/Service.svc
You're using BasicHttpBinding

You then need to synthesize the SOAP input XML. If you think that sounds boring, you could always copy it from an actual call made with a thicker client (like a .NET program or WcfTestClinet). Fiddler can help you with this.

For the example service given above under the given circumstances (BasicHttpBinding), this is a valid SOAP 1.1 XML input:

 <s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
   <Hello xmlns="http://tepmuri.org/myservice/">
    <name>world</name>
   </Hello>
  </s:Body>
 </s:Envelope>

Let's say you've saved this text into a file called hello.xml. To perform the call, execute the following wget command from the command line:

wget --post-file "hello.xml" --header "content-type: text/xml;charset=utf-8" --header "SOAPAction: http://tepmuri.org/myservice/IService/Hello" http://localhost/Service.svc

There's really not much to it We need four parameteres

The input XML as a filename
A HTTP header specifying the content-type
A HTTP header specifying the SOAP Action name with full namespace
URL of the service

If you've done everything correctly, you should get a 200 return code and the SOAP XML Body in the HTTP Body.

Using WsHttpBinding (SOAP 1.2)

Now if you're using WsHttpBinding, you need a slightly more complex input XML. Use this as a starting point:

 <s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">
  <s:Header>
   <a:Action s:mustUnderstand="1" >http://tepmuri.org/myservice/IService/Hello</a:Action>
   <a:MessageID>urn:uuid:149c449f-0593-416b-ae1f-b73308a6e2d2</a:MessageID>
   <a:ReplyTo>
    <a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address>
   </a:ReplyTo>
   <a:To s:mustUnderstand="1">http://localhost/Service.svc</a:To>
  </s:Header>
  <s:Body>
   <Hello xmlns="http://tepmuri.org/myservice/">
    <name>world</name>
   </Hello>
  </s:Body>
 </s:Envelope>

In addition you'll need to change the content-type HTTP header of the wget command to the following:

-header "Content-Type: application/soap+xml; charset=utf-8"

A couple of more wget paramteres that might come handy:

HTTPS: If you're exposing the service with HTTPS security and you have a temporary SSL Certificate, use --no-check-certificate
Proxy: Wget takes proxy credentials on the command line, but the URL is specified by an environment variable named http_proxy. Running SET http_proxy=localhost:8888 on the command line before wget will redirect all commands through a proxy (like i.e. fiddler)

Using WF4 as a Business Rule Engine

2011-11-15T09:05:00.000-08:00

Introduction

A project at work forced me to get up to speed on Windows Workflow Foundation (WF) quickly. My boss wanted to use it as a business rule engine where the end user could edit the rules themselves. They didn't necessarily need full flexibility on the editing, but the core parameters of the rules had to be editable. Now there's probably hundred ways to approach this, and many ways to do it without using Workflow Foundation, but I decided do a proof of concept doing so.

I then came over Christophe Geers' Blog and the article Using Rules outside of a Workflow. This was the kind of kick-start I needed - or so I thought, until I noticed it targets WF3 (Workflow for .NET 3.5). Now I could go on and use WF3, but some Googling and reading lead me to believe i would be better prepared for the future using WF4 instead*. In this article I will implement the same application as Christophe Geers did, but in Workflow 4.

*) You may argue against this in the comment field if you like - I'm still not sure this is an obvious choice.

Workflow 3 vs 4

So what has changed? A lot. Microsoft has rewritten the Workflow framework quite extensively from WF3 to WF4, and the way you work with Rules is fundamentally changed. Long story short, I feel they've tried to generalize the concept of an element in a workflow to the point where "everything is an apple". Maybe they've succeeded - I really haven't worked long enough with the framework to comment on this. Anyway, a Rule is now a basically an Activity configured accordingly. The Rule class is obsolete. I will not go into detail on the changes - Microsoft have published a 17 page document comparing how to use the concept of Rules in the document WF Guidance: Rules which is a part of the WF4 Migration guide

The Salutation Resolver Solution

Christophe Geers implemented a rule set in WF3 which basically decides the correct salutation in a letter for a person given some basic properties about that person. I'm not going to go into the same level of detail regarding the problem domain as Geers did, instead I'll focus on how to implement it in WF4. For reference, go to his blog entry at any time. This table will describe the expected result though:

Gender	Age	Married	Salutation
M	>18	Yes/No	Mr
F	>18	No	Miss
F	>18	Yes	Mrs
F/M	<18	Yes/No	To the parents of

Gender

Age

Married

Salutation

>18

Yes/No

>18

Miss

>18

Yes

Mrs

F/M

<18

Yes/No

To the parents of

The solution will be divided into three projects:

A shared library with the business entities
A Forms project which take input and allow you to edit rules
A Workflow Activity project. This is where the juice is.

The Forms project contains two forms. The parameter input form looks like this:

It will allow you to change the input parameters and see how the result of the workflow execution changes accordingly. The second form is for altering the business rules runtime. I will come back to that later.

The shared library contains two important classes - Person.cs, which is basically identical to the one from Geers' blog, and SalutationAssignmentRule.cs which is a wrapper over the rules we define, and the core of what we will expose to the end user.

The Activity project contains logic and data for executing the business rules in one of three ways:

From a Workflow diagram designed with the Visual Studio Designer.
From a hard-coded workflow where all the logic is written in C# code
From a dynamic workflow where the workflow logic is generated from user input by C# code

#1 is cool. The designer produces XAML of the workflow (or "business rules"), which is suited for persitance and to a certain degree modification. I didn't really see my endusers editing XAML or using Visual Studio to change the business rules though, so this option was not for me.

#2 is cooler. Here I prove that the same can be done in code. Articles like DynamicAcitivty Creation and Kushal Shah's Adding Variables, Expressions and Bindings Programmatically helped me accomplish this, but the way I implemented it, the rules are pretty static.

#3: Now we're getting somewhere. By adding a layer on top of the code in #2, we can expose part of the rules to the end users. In this example I go as far as exposing the Visual Basic-style condition statements and the if-then-else-assignments to the user interface. This may be overkill for my end users, but I'm showing that the flexibility is there. See screenshot below.

In this DataGridView you can edit the rules runtime.

The implementation

I will focus on solution #3 from last chapter - where dynamic rules are used. For the other methods, download view the solution yourself (link at bottom).

First, the "dumb" business classes:

Here is the gist of Person.cs. -Only syntactically altered from Geers' blog:

public class Person
  {
     #region Properties
     public string Name { get; set; }
     public string Firstname { get; set; }
     public DateTime BirthDate { get; set; }
     public string Gender { get; set; }
     public bool Married { get; set; }
     public string Salutation { get; set; }
     // Read-only properties:
     public Int32 Age { get { return CalculateAge(); } }
     public Boolean Minor { get { return (Age < 18); } }
     // Methods
     private bool CalculateAge() { /* Implementation */ }
  }

Then there is the class for storing the business rules. I need to wrap the complex structure of activities, sequences and arguments from the framwork in a manner that is easier presented in a user interface. In this solution I bind a list of these objects directly to the datagrid.

public class SalutationAssignmentRule
    {
        public string Condition { get; set; }
        public int Priority { get; set; }
        public string ThenValue { get; set; }
        public string ElseValue { get; set; }
        public string TargetParameter { get; set; }

        public SalutationAssignmentRule(int priority, string condition, string thenValue, string elseValue = null)
        {
            TargetParameter = "Person.Salutation"; // Could be configurable
            Condition = condition;
            Priority = priority;
            ThenValue = thenValue;
            ElseValue = elseValue;
        }
    }

The ActivityLibrary projects is where the magic happens, specifically in SalutationRuleGeneratorDynamic.cs and RuleConverter.cs. The latter converts Rules in the form of SalutationAssignmentRule-objects to WF4 activity objects of type If, which are a subclass of the "everything-is-an-apple"-Action class.

RuleConverter.cs:

public class RuleConverter
  {
      internal static Activity ToIfActivity(SalutationAssignmentRule inRule)
      {
          var condition = new VisualBasicValue(inRule.Condition);
          var ifActivity = new If(new InArgument(condition));
          ifActivity.Then = new Assign
          {
              To = new OutArgument(new VisualBasicReference(inRule.TargetParameter)),
              Value = new InArgument(inRule.ThenValue)
          };
          if (inRule.ElseValue != null)
          {
              ifActivity.Else = new Assign
              {
                  To = new OutArgument(new VisualBasicReference(inRule.TargetParameter)),
                  Value = new InArgument(inRule.ElseValue)
              };
          }
          return ifActivity;
      }
  }

Note how the condition, which is a string sounding something like Person.Gender = "Male", is input to the If-class directly. By wrapping it in a VisualBasicValue, it will be interpreted runtime.

Now there's a caveat here: The root Workflow object needs to have a Workflow-property set, indicating that VB-statements will be present in the Workflow. A method to add such a parameter to an Activity is implemented in Common.cs:

internal static void AddVbSetting(Activity activity)
  {
      var settings = new VisualBasicSettings {
          ImportReferences = { new VisualBasicImportReference {
              Assembly = typeof(Person).Assembly.GetName().Name,
              Import = typeof(Person).Namespace } } };
      VisualBasic.SetSettings(activity, settings);
  }

If you look at the Visual Studio-generated XAML for the SalutationRules workflow, you will find the same setting generated there, in the tag <mva:VisualBasic.Settings>.

Going further up the implementation chain, we have the core Workflow generator class in SalutationRuleGeneratorDynamic.cs:

public static Activity CreateSalutationRules(List rules)
  {
      var inProperty = new DynamicActivityProperty
      {
          Name = "Person",
          Type = typeof(InArgument)
  
      };
      var activity = new DynamicActivity() { Properties = { inProperty } };
      Common.AddVbSetting(activity);
  
      var sequence = new Sequence();
      activity.Implementation = () => sequence;
  
      // Sort descending - those added first are lowest priority
      var sortedRules = rules.OrderByDescending(p => p.Priority).ToList();
      
      // Convert to if-activities and add to sequence
      foreach (var inRule in sortedRules)
      {
          var outRule = RuleConverter.ToIfActivity(inRule);
          sequence.Activities.Add(outRule);
      }
  
      return activity;
  }

The key thing to notice here is how I order the rules by priority to emulate the Priority property of the Rule class of WF3. When you emulate Rules by using a flat list of If-activities as I do here, you get implicit priority by the order of which you add the If's to the Sequence object.

Finally there is the invocation code. In WF3, you'd instantiate a RuleExecution class followed by an Execute. In WF4 the equivalent is the static method WorkflowInvoker.Invoke(). Again, this is a general Workflow executer meant for everyone - not just for us weirdos using WF4 as a Business Rule Engine.

private void ExecuteRules(Activity activity, Person person)
    {
        var input = new Dictionary();
        input.Add("Person", person);
        WorkflowInvoker.Invoke(activity, input);
    }

Persisting code-generated workflows

Before I round up, I'd like to mention that if you want to generate XAML from the code-generated activities for storage or transport purposes, you're just a small step away. I didn't include the code for it in my solution, but the key is to swap the DynamicActivity-instantiation in the CreateSalutationRules-method with a ActivityBuilder-class. The article Serializing workflows and Activities to and from XAML illustrates how to to this. You will have to do some minor syntactical changes in the CreateSalutationRules-method for it to compile, and also probably have to go thorugh a serialization-deserializiation-process before ending up with an executable Workflow.

In closing

To summarize - yes you can implement Rules in WF4. Is it easier than in WF3? I don't think so. Is it faster? I don't know. Microsoft says it is. Is it better? Maybe. Depends on what your needs are. In some regards, WF4 have actually less functionality than the Rules in WF3 - forward chaining of rules is an example of functionality you will NOT get by using WF4 as a BRE. In other areas, WF4 will provide you with more functionality though. The "rules" are no longer restricted to the If-then-else-structure of WF3. You can define a rule as any activity in the Workflow namespace. For the example Christophe Geers and I presented, the differences would not matter much though. Others will have to answer for more complex problem domains.

Downloads

Either clone the repo by running this command:

git clone https://github.com/Nilzor/wf4-rule-engine.git

...or download this ZIP (VS2010 solution): WF4-SalutationRules.zip

Update 25th Nov 2011: Turns out there's a better way to create the dynamic activity when you have static input- and output parameters as in this case. By creating a class that inherits Activity, you get to create the parameters as standard C# properties instead of generating InArgument-objects that must manually be added to the Properties collection of the Activity class.

Updated class for the dynamic activity: DynamicSalutationRulesActivity.cs (replaces SalutationRuleGeneratorSynamic)

Thanks goes out to Willem Meints and his blog for this knowledge :) He has a good three-post article about different ways of creating dynamic activities here: part one - two - three. (How come I find all the good articles about WF4 in the Benelux-lands? :p)

Synchronize your Outlook tasks with Android

2011-10-01T10:11:00.000-07:00

The task list in GMail

The tasks list in Google Calendar

The Google Canvas web-interface for tasks

GTasks widget on an Android phone

There is no native way of synchronizing your Outlook tasks to an Android-based phone or pad directly as of today. You can synchronize your e-mail and calendar using the Outlook Exchange protocol, but that protocol does not support tasks. Many developers have made efforts to work around that issue and created third party tools that allow you to synchronize via cloud services such as Remember the Milk or ToodleDo. These services will all get the job done, but if you are a Google Mail and Calendar user like me, the more natural cloud service for my tasks would be the Google Task list. This is the alternative I will present in this article.

The Google Task list is a service that is available both through GMail and the Calendar, or at the standalone interfaces Google Tasks Canvas or the Hand-Held Device Interface. See screenshots to the right. To synchronize with Outlook using Google Tasks as the "man in the middle", you'll need two applications: one at the iPhone and one at the computer running Outlook.

1. At the Android device

There are several tools for Android devices that will let you work with Google Tasks, for example GTasks and Google Tasks Organizer (GTO). I'm using GTask, so that's what I'll be using as an example here. I'm sure there are even more alternatives, but GTasks gets the job done. The free version is ad-based, but you can upgrade for ~$8. That said, the price of GTO is only $3, but it does not have widget support (as of now). A widget is really useful if you ask me. Then you can have the most pressing task list "just a flick away" at one of your home screens. See the screenshot to the right for an example.

2. At the computer

Here the only tool I know of is called GogTasks. Incidentally, I'm also the developer of this tool, so a little disclaimer goes out right now ;-) They say that all developing projects starts because the developer wants to "scratch their own itch", and that is also the case here. I needed to get my daily life organized, not forgetting things that needed to get done, and I discovered the lack of a sync tool between Outlook og Google was a hindrance. So I made GogTasks, and this tool will be the second element in getting the iPhone-Google-Outlook-sync up and running.

GogTasks works for both Outlook 2003, 2007 and 2010. You can set it up to synchronize at a regular interval so you basically don't need to worry about it being there at all.

Putting it all together

As soon as you've configured GTasks (or GTO) and GogTasks to sync against your GMail account, there's not really much to it. Synchornize your tasks, and they will be available wherever you are - on the bus with your phone/pad, by your work computer with Outlook, or from the internet café in Amsterdam when your there to... visit your aunt.

One thing you should be aware of though, is that Outlook have a much more rich concept of a "Task", with things such as recurring tasks and assigning it to multiple categories. Read about how GogTasks handles that here

The final picture:

The device

Google

Outlook

Synchronize your Outlook tasks with iPhone

2011-10-01T08:07:00.000-07:00

The task list in GMail

The tasks list in Google Calendar

The Google Canvas web-interface for tasks

There is no native way of synchronizing your Outlook tasks to iPhone directly as of today. You can synchronize your e-mail and calendar using the Outlook Exchange protocol, but that protocol does not support tasks. Many developers have made efforts to work around that issue and created third party tools that allow you to synchronize via cloud services such as Remember the Milk or ToodleDo. These services will all get the job done, but if you are a Google Mail and Calendar user like me, the more natural cloud service for my tasks would be the Google Task list. This is the alternative I will present in this article.

1. At the iPhone

There are several tools for iPhone that will let you work with Google Tasks, for example GeeTasks or GoTasks. I've tried GoTasks, so that's what I'll be using as an example here. I'm sure you can find other alternatives if you search for it, but I'm not sure you'll really need one. GoTasks gets the job done and has a good and intuitive user interface. This, and it's free!

2. At the computer

GogTasks works for both Outlook 2003, 2007 and 2010. You can set it up to synchronize at a regular interval so you basically don't need to worry about it being there at all.

Putting it all together

As soon as you've configured GoTasks and GogTasks to sync against your GMail account, there's not really much to it. Synchornize your tasks, and they will be available wherever you are - on the bus with your iPhone, by your work computer with Outlook, or from the internet café by the beach when you're on vacation (not that you'd really want to get anything done at this time :-).

The final picture:

Your iPhone

Google

Outlook

Linq2EF pitfall: Using Length property causes System.NotSupportedException

2011-08-15T06:15:00.000-07:00

ArrayLength is not supported in LINQ to Entities

I spent the last half of previous friday banging my head against the wall over a System.NotSupportedException being thrown by Entity Framework 4.0. Now this might be related to the very fact that it was friday and my mind had already started drifting elsewhere, but I wasn't even close to finding the source of the problem. The exception messages sounded "The LINQ expression node type 'ArrayLength' is not supported in LINQ to Entities". When I saw 'ArrayLength' mentioned there, and stepping through the code in debug mode seeing that it failed in the foreach statement, I assumed the query went OK but Entity Framework was unable to traverse the result set. This was wrong.

You cannot use the .Length property of a VARBINARY field in the where clause of an Entity Framework query.1)

Now this may not come as a surprise to you, unless you've used Linq2SQL. You can there.

This problem is solved by rewriting the Length check to use the EF static method SqlFunctions.DataLength instead. This will result in EF producing a TSQL statement where the TSQL function DataLength is used on the property in question. This is incidentally what Linq2SQL does behind the scenes as well, without having to be told explicitlty (I found out that by using LinqPad).

1) This probably goes for the select clause as well, and for all fields having an intrinsic lenght/size property, but this is what I have tested in specific.

A small example - the wrong way

                var results = db.Customers.Where(p => p.PicutereBlob.Length > 0);
				foreach (var customer in results) { /* Do something */ }

Now the exception occurs on line 2 - one of the reasons for my confusion last friday. But of course, that's how Linq and Entity Framework operates.

A small example - the right way

                var results = db.Customers.Where(p => SqlFunctions.DataLength(p.PicutereBlob) > 0);

...or in plain Linq syntax:

from p in Customers
SqlFunctions.DataLength(p.PicutereBlob) > 0
select p

Resulting SQL query:

SELECT 
[Extent1].[PictureBlob] AS [PictureBlob], 
FROM [dbo].[Customers] AS [Extent1]
WHERE ( CAST(DATALENGTH([Extent1].[PictureBlob]) AS int)) > 0

This will be the statement given that PictureBlob is the only field in the table Customers.

By the way, This output is semi-directly copy-pasted from the console output while using the brilliant library provided by Jaroslaw Kowalski at his MSDN blog. This gives you the power to monitor all generated SQL queries from the client. A feature which again, Linq2SQL has by default. This in turn leads to the discussion of why we use Entity Framework in the first place, but I'm not going to delve into that hornet nest.

Income from paid vs ad-based app

2011-07-11T07:13:00.000-07:00

When I published my last post, Android vs WP7 - A case study, I said I had plans to release a free, ad-based version of the app for Android to compare income from ads to income from sales. What's said is done and I hereby present you with the magic numbers.

Application	Downloads	Earnings
Android, Free (Ads)	356	$1.75
Android, Paid ($1)	50	$43.11
WP7, Paid ($1)	75	$52.50
This blog (Ads)	N/A	$42.90

It should be noted that the ad-based Android app has been on the market a good two months less than the other products in the table. It was released some time in March 2011 (exact date not noted) and the results are collected today, July 11th.

As you can see, the "income" from the ads from the free version of Flags and Capital Quiz is ridiculously low, even if we compensate for the missing two or three months of market time. Although the volume of the sample data in this "analysis" is far from big enough to draw any absolute conclusions, I think it gives some interesting indications. I for one am not going put all my eggs in the basket of ad-based apps for the Android platform.

As a fun fact I included the earnings I've had for ads on this page (Google Adsense) in the same period of time. I guess one can't conclude that blogging is more lucrative than writing phone apps based on this, but well...

When this is said, a interesting new feature has been introduced to the Android platform since I last wrote. Well a lot of interesting new features have been introduced actually, but the one of interest in this context is the ability to exexute in-app billing on the platform. This basically gives us the same possibilies as the Trial mode flag on the Windows Phone 7 platform. It just takes a couple of hundred more lines of code ;-)

Still I'm quite interested in seeing the development of the use of in-app billing in the developer community. Because of the quite crappy income genereated from ads, I'd expect more developers to go for the Trial/Full version licensing model in the time to come. I know a great deal already are, by publishing two separate apps, but I think it will be even more popular with the new model.

Android vs WP7 for developers - a case study

2011-01-06T11:28:00.000-08:00

Introduction

I started my mobile apps "development career" last year by publishing a couple of tools for the Windows Mobile 6.5 platform. I quickly grew fond of the whole apps concept - low threshold for getting started and small programs meaning short projects time-wise. Also the platform took care of the distribution and monetary transactions for me, so that I could care about the thing I find most fun - coding.

It didn't take very long until I realized I had to start thinking about other platforms, though. The Windows Mobile 6.x platform (WM6.x for short) was already lagging behind Apple and Google user experience-wise, and the nail in the coffin came when Microsoft announced Windows Phone 7. Everyone who've done their research know that the Windows Mobile 6.x platform is as different to Windows Phone 7 as Android is to iOS, so although I was already into Microsoft technology, I knew the choice for my next mobile operating system was anything but given. I had already ruled out Apple iOS for several reasons not relevant here, so my choice was between the rising star of Android from Google, and Microsoft's new undertaking in the cell phone world - Windows Phone 7 (WP7).

Microsoft seemed very serious about their new venture. High-ranking Microsoft-guys were preaching the awesomeness of the new platform on conventions and in media all over the world. It seemed like they put a lot of resources into developing the framework and the IDE. At the same time the developers on the WM6.x like me, were given extra attention and information and after a while even offered to get a physical WP7 phone before the official release. It seemed like the path of least resistance to move over to WP7, even though I had to learn Silverlight, but at the same time my friend had bought a HTC Hero phone. Which I found quite cool.

The Android platform, which HTC seemed to embrace here in Scandinavia, was quickly growing in popularity. iPhone had been the sole market leader for a couple of years and I think the public wanted something new and fresh. Android could seem to be exactly that. They had the sleek look and feel of the iPhone, while taking the technology a step further, which entices us geeks. I was beginning to suspect that this over time could be the new market leader or at least compete with the iPhone. I had done a bit of Java programming at the University, so I wasn't afraid to try that again, although I knew I had to read up on the framework.

The technology wasn't a big factor in the decision I had to take. First and foremost I wanted to make money. Most money with least effort - that was basically my goal (isn't everyone's?). Technology is of course a factor when it comes to effort, but most important was which phone was most attractive to the public, hence giving me the largest market. This was of course not possible to say when WP7 wasn't even in the stores yet. I could only assume that Android would have the market lead for at least half a year after the launch of WP7, if not longer (or forever). But money wasn't all - it needs to be fun as well. I'm doing this on my spare time, and if it's not fun, I won't do it. Could WP7 make up for the lack of market share with the fun factor in the development process?

This leads me to the topic of this blog. I decided to do a test. I mean, you can't know which chocolate tastes best before you've tried both, right? (You may quote me on that). For the test to be fair, I decided to make the exact same application on both platforms, and see where it got me. The application had to be simple so that I could do it in a short period of time, but not so simple that it didn't put the framework and IDE to a test. I was going to note down my experiences during the process and write about the result here. I decided this some time in September, and the 20th of November I released the app on the second platform, completing my project.

The App

I decided to go for a simple game I had seen the likes of at the iPhone platform and also on Android: A flag and country quiz. It would require some graphics, some business logic and probably some storage. Enough for a basic test, but far from a thorough. I would not be leveraging any of the more advanced hardware or even a network connection or sound device, but I wanted to be done in a couple of months - and I had to learn not one, but two new frameworks. But most important - the complexity of the programming (or lack of it) is not directly relevant to sales numbers - the prime factor I wanted to compare. This simple game should suffice, was my conclusion.

A quick overview of the game, which is called "Flags and Captital Quiz" on both platform:

There are five game modes:

Guess country name from the picture of a flag
Guess the flag from the name of a country
Guess the capital from the country name
Guess the country name from the capital
A mixed mode which alternates randomly of the four above

All five modes each give four alternatives for the answer, so the user simply picks one of them by clicking on it. A couple of screenshots:

The IDEs

This chapter describes the differences in the extended IDEs, meaning both the editor, compiler, debugger and emulators.

Android

For those of you who've never developed in Java, the preferred IDE is called Eclipse and can be downloaded for free at www.eclipse.org. In addition you'll need the Android SDK from Google which acts as a plug-in in Eclipse. It will also provide you with the Android emulator to test your software without a physical device.

The installation went smooth, nothing to complain about here. Eclipse in itself is also a pretty smooth IDE. It has some semi advanced features that Visual Studio didn't have until the 2010-version, which is quite impressive. I'm thinking of things like code inspection reporting instantly of non-used variables, syntax errors and more. It also have some refactoring features but I haven't delved into these. The debugger has all the functions you'd expect, although I do have some complaints on usability here. I find inspecting variables and object hierarchies run-time easier in VS2010, but it might be that I haven't understood properly how to use it yet. But all in all the feel of Eclipse is good. It's fast and feels light-weight even though it isn't.

Where Eclipse comes short compared to Visual Studio is in designing UI. There simply is no designer in Eclipse. You need to rely on your XML skills and ability to visualize XML as UI components. Or use a tool like DroidDraw. But even the combination of Eclipse + DroidDraw falls way short of the design capabilities of VS2010 working with Silverlight projects.

Visual Studio 2010

If I would describe Visual Studio 2010 in one word, I would say huge. It's huge in all aspects: Installation process, disk footprint, runtime footprint, features, everything. But as long as you have a machine capable of hauling it, it's a dream to work with. I just had to make space for the 3 GB of disk requirement on C: before I could start (You do need 3 GB free space on C: even if you chose to install it on D:, meaning my tight fragmentation strategy of the C-partition failed).

Visual Studio have basically all the same core features as Eclipse, so the coding experience itself is not much different. There is one aspect I found slightly better in the Microsoft world, and that's the phone emulator. It's better integrated in the IDE for natural reasons (Microsoft produce both the IDE and the emulator), and this results in a lightning fast and stable launch process. The first boot of the emulator takes time, but after it is up an running, I literally only wait two seconds from I've made a code change and hit F5 (debug), until it's up and running in the emulator. Not once did I face any problems running the app, while with the Android emulator I experienced increasing problems towards the end of the project with getting Eclipse to connect to the Android debugger. Frequent restarts had to be done of both Eclipse and the debugger.

Ignoring the slight problems I had with connecting the debugger to the Android emulator, the major difference between the IDEs is the designer (or the lack of in the case of Eclipse). Hard-core coders who frown upon using visual tools to do the design have no respect with me. I use whatever tool gets the job done quickest and with best result. If drag-and-drop creates code 10 times faster than I could write it, no matter how much intellisense support there is in the IDE, I use drag-and-drop. But more important than coding speed itself is how much easier it is to design. Our brain (or the right hand side of it at least), responds much quicker to concrete visual modelling than abstract representation in the form of XML or XAML. This is where the real time-saver is. You instantly see why the three Images underneath the ListBox with four icons is a good or bad idea - no need to compile and run first.

Summary

Eclipse	Visual Studio 2010
Instant code analysis feedback is good in Eclipse	Changes you do in the left view instantly results in XAML code change in the rigght, and vice versa.
Lightweight / fast / responsive	Quick and stable emulator
Free	Great visual designer
No visual designer	Huge footprint

Eclipse

Visual Studio 2010

Instant code analysis feedback is good in Eclipse

Changes you do in the left view instantly results in XAML code change in the rigght, and vice versa.

Lightweight / fast / responsive

Quick and stable emulator

Free

Great visual designer

No visual designer

Huge footprint

Update 7th Jan: I was noted that the development tools for WP7 are actually also free - the Visual Studio Express and Blend for Windows Phone 7 are free of charge. They can be installed alongside any other preexisting Visual Studio installation.

The Android emulator	The WP7 emulator
Boots fast, launches programs fast. Solid. Had some problems connecting to the debugger from time to time, but might be a configuration-problem.	Also solid. The emulators are really not what make the difference.

The Android emulator

The WP7 emulator

Boots fast, launches programs fast. Solid. Had some problems connecting to the debugger from time to time, but might be a configuration-problem.

Also solid. The emulators are really not what make the difference.

The development process and the APIs

In this chapter I will describe the development process session by session on the two platforms, emphasizing the events that stand out as positive or negative. Finally I will summarize what I find good and bad about the frameworks (APIs) that is the Android SDK and the WP7 / Silverlight framework.

For Android I used the Android 1.6 SDK
Windows Phone 7: Standard WP7 project based on .NET 4.0

For those of you who are confused about the Windows Phone 7 SDK stack, this is the gist of it

C# is the programming language
.NET 4.0 is the core libraries (non-UI-functions)
Silverlight is the SDK which enables rich UI for web, Windows and WP7, but:
The Windows Phone 7 SDK is a subset of Silverlight and .NET 4.0 - not all functions and UI elements from Silverlight 4 or .NET 4.0 exists on WP7.

Android

#	Time spent	What
1	1h 30min	Collected and organized data: Flags, capitals and countries from the CIA World Factbook
2	3h 20min	Read basics on Android development, learning Eclipse better Google have documented Android well. Well structured and written.
3	4h	Worked on designing and implementing code for my first pages (Activities). Spent time both in XML and in Java code. Wasted a lot of time trying to figure out how to pass parameters with intents. Ended up using global variables instead. Soon got tired of XML-juggling. Little IDE-help here.
4	2h 30min	Spent most time trying to figure out how to make buttons turn red and green after an answer had been made. Tried three approaches before finally finding the right answer on the net (Hint: Drawable.setColorFilter()).
5	2h 30min	Working on business logic. Three out of five quiz modes complete.
6	1h	Mixed mode implemented.
7	1h 30min	Settings screen (activity) implemented. Functionality for saving/loading said settings still remain.
8	4h	Implemented practice and score mode. Textual "fun" feedback on the results. Half done with high score list functionality Getting problems attaching to the debugger more often. Restarts requried. Annoyed by the fact that hitting F5 when an XML file is in focus, the app is not launched, but instead Eclipse tries to launch XML files in a special manner, effectively forcing me to clean the entire project and rebuild. Wasting some time on this.
9	4h	Spent some time drawing icons. High score list implemented. Icon swapping in high score list. The project is starting to show signs of a lot of copy-pasted code in the activities. Probably because of bad design - for instance, Custom components is a conecpt I did not bother to read up on.
10	3h 30min	Last mode, flag from country, implementation beugn. Most demanding activity XML.
11	3h	Completed flag from country mode. Implemented saving and loading of settings and high scores with JSON serialization. Saving and loading user settings is well supported and easy to use in the Android framework Object serialization in the Java world could have been easier (used for high score object hierarchy). I used standard org.Json-functions. There is a library called Gson that probably could have made my code prettier, but at this point I did not want to introduce additional third-party libraries in my project.
12	1h 30min	Completion of diverse functionality
13	5h	Some bug-fixing. Fixed memory leak (image data was not freed). Created application icon. Published at Saturday 21th of October.. The publishing process went smooth and was straight forward.

Time spent

What

1h 30min

Collected and organized data: Flags, capitals and countries from the CIA World Factbook

3h 20min

Read basics on Android development, learning Eclipse better

Google have documented Android well. Well structured and written.

Worked on designing and implementing code for my first pages (Activities). Spent time both in XML and in Java code. Wasted a lot of time trying to figure out how to pass parameters with intents. Ended up using global variables instead.

Soon got tired of XML-juggling. Little IDE-help here.

2h 30min

Spent most time trying to figure out how to make buttons turn red and green after an answer had been made. Tried three approaches before finally finding the right answer on the net (Hint: Drawable.setColorFilter()).

2h 30min

Working on business logic. Three out of five quiz modes complete.

Mixed mode implemented.

1h 30min

Settings screen (activity) implemented. Functionality for saving/loading said settings still remain.

Implemented practice and score mode. Textual "fun" feedback on the results. Half done with high score list functionality

Getting problems attaching to the debugger more often. Restarts requried.

Annoyed by the fact that hitting F5 when an XML file is in focus, the app is not launched, but instead Eclipse tries to launch XML files in a special manner, effectively forcing me to clean the entire project and rebuild. Wasting some time on this.

Spent some time drawing icons. High score list implemented. Icon swapping in high score list. The project is starting to show signs of a lot of copy-pasted code in the activities. Probably because of bad design - for instance, Custom components is a conecpt I did not bother to read up on.

3h 30min

Last mode, flag from country, implementation beugn. Most demanding activity XML.

Completed flag from country mode. Implemented saving and loading of settings and high scores with JSON serialization.

Saving and loading user settings is well supported and easy to use in the Android framework

Object serialization in the Java world could have been easier (used for high score object hierarchy). I used standard org.Json-functions. There is a library called Gson that probably could have made my code prettier, but at this point I did not want to introduce additional third-party libraries in my project.

1h 30min

Completion of diverse functionality

Some bug-fixing. Fixed memory leak (image data was not freed). Created application icon. Published at Saturday 21th of October..

The publishing process went smooth and was straight forward.

WP7

#	Time spent	What
1	1h 30min	Started designing the pages (Activities on Android). Finding the WP7 documentation pages slightly harder to navigate than the one for Android as I try to read up on Silverlight design concepts.
2	1h	Trying to apply databindning. Having worked with databinding on WinForms, doing the same on Silverlight is a step back. You suddenly need to write XAML and learn meta-syntax in quotation marks that I still haven't quite figured out. Copy-paste is your friend.
3	3h 30min	Button colouring, flag animation, practice mode and score mode. Note: I did not implement any animation on the Android version, so I'm slightly deviating from the "same app, different platform" concept of my review here, but I couldn't help myself but leverage the animation capabilities of Silverlight. The animation features in Silverlight are awesome. Takes a bit of learning, though.
4	1h 30 min	High score logic implemented (no storage)
5	1h 30min	More work on the high scores screen. Refactoring pages a bit - creating UserControls for the image buttons used in the high scores view and a control for the score bar in the quiz pages
6	3h	Applcation icon included in project. Struggled a bit with getting it to display properly. Turned out it had to have the build action property set to "Content". Save and load of high scores. Support for tombstoning (when app sleeps in background) implemented. The tombstoning concept was a pain in the ass. No such thing on Android, but this is a consequence of the non-multitasking nature of WP7, I guess Object serialization is fortunately a breeze in .NET, which helps when saving object state when tombstoning.
8	5h	Refactored all quiz mode pages to user controls. Now mixed mode was implemented in half an hour. Flag from country mode implemented The App Manifest is auto-generated as opposed to on Android. Meaning the compiler among other things auto detects what kind of hardware resource your application will be utilizing. VS2010/XAML editing lacks good support for refactor-renaming things like animation timeline names
9	1h	Improved some animation (half hour) and added support for trial mode, which is a feature unique to the Microsoft Marketplace. You may actually provide the user with an option to try before they buy the software, all which is controlled with a single boolean in your code. Simple and effective! The IsTrial boolean is brilliant
10	0h 30min	Submitted at the 20th of November. Read more about submission process below

Time spent

What

1h 30min

Started designing the pages (Activities on Android).

Finding the WP7 documentation pages slightly harder to navigate than the one for Android as I try to read up on Silverlight design concepts.

Trying to apply databindning.

Having worked with databinding on WinForms, doing the same on Silverlight is a step back. You suddenly need to write XAML and learn meta-syntax in quotation marks that I still haven't quite figured out. Copy-paste is your friend.

3h 30min

Button colouring, flag animation, practice mode and score mode. Note: I did not implement any animation on the Android version, so I'm slightly deviating from the "same app, different platform" concept of my review here, but I couldn't help myself but leverage the animation capabilities of Silverlight.

The animation features in Silverlight are awesome. Takes a bit of learning, though.

1h 30 min

High score logic implemented (no storage)

1h 30min

More work on the high scores screen. Refactoring pages a bit - creating UserControls for the image buttons used in the high scores view and a control for the score bar in the quiz pages

Applcation icon included in project. Struggled a bit with getting it to display properly. Turned out it had to have the build action property set to "Content". Save and load of high scores. Support for tombstoning (when app sleeps in background) implemented.

The tombstoning concept was a pain in the ass. No such thing on Android, but this is a consequence of the non-multitasking nature of WP7, I guess

Object serialization is fortunately a breeze in .NET, which helps when saving object state when tombstoning.

Refactored all quiz mode pages to user controls. Now mixed mode was implemented in half an hour. Flag from country mode implemented

The App Manifest is auto-generated as opposed to on Android. Meaning the compiler among other things auto detects what kind of hardware resource your application will be utilizing.

VS2010/XAML editing lacks good support for refactor-renaming things like animation timeline names

Improved some animation (half hour) and added support for trial mode, which is a feature unique to the Microsoft Marketplace. You may actually provide the user with an option to try before they buy the software, all which is controlled with a single boolean in your code. Simple and effective!

The IsTrial boolean is brilliant

0h 30min

Submitted at the 20th of November. Read more about submission process below

Summary

Total time on Android: 35 hours 30 minutes
Total time on WP7: 18 hours

These numbers lie

There are several reasons the WP7-development went faster.

I had the resource files ready (flags and data xml's)
I could reuse architectural principles i used in the Android project (brain time)
I reused actual code by copy-pasting and changing "boolean" into "bool" etc. (code time)

All in all I think this is much closer to a draw time-wise than what my numbers show. I think the main difference is not development time, but what I got out of that time. The WP7-version is simply cooler because of the animation effects I so easily could add.

In any case, I did a breakdown on the numbers, dividing time spent into five categories: Gathering and prepare resources (images, dat), Studying (googling and reading), Coding (actual C# or Java work), UI-develpoment (XML/XAML) and publishing. You do need to take these numbers with a grain of salt. It's very difficult to say exact how much time I spent on each activity, but I think it gives an indication. Instead of presenting the numbers in a table, I made these beautiful pie charts:

Android	WP7

The most interesting fact I get out of these pie charts is the difference in time spent doing "UI". Now this may be a question of definition, but I did spend proprtionally more time working in the designer and with XAML than with code on WP7 compared to Android. Maybe it's because Silverlight more fun, so I took time to work on things like animation and stuff? Maybe it's because I knew better what to code, so that the business logic was done faster the second time around? Probably a combination.

The submission process

The sumbission process are pretty similar. I suppose Google and Microsoft have learned from each other and copied some ideas. The basic info you need to fill out and upload on both places are:

Name
Description
Binaries
Icon, screenshots and artwork
Pricing details

There are some slight differences.

The android platform requires you to enter a content rating (Teen/Mature, etc)
The WP Marketplace allows you to price the product differently in different countries.
Android allows advanced copy protection with a licensing server. Takes some implementing. Unsure where WP7 stands here.
WP7 allows support for trial mode

The last bullet point here is a big plus for the Windows Phone Marketplace, if you ask me. This allows users to download a single binary that acts as a trial until the user purchases the product. It is then unlocked by setting a bool IsTrial=true, which you must have code for. This way, publishers don't have to upload two separate versions, which I see is very common on the iPhones. On the Android platform though, I see the norm is more to publish ad-based applications. But maybe it would be different with the Trial-option there as well.

All in all, both platforms allow a good user interface for uploading applications. When you have your material ready, the publishing itself is done in half an hour or less. As a side note, for those of you who've worked with Windows Marketplace for Windows Mobile 6.5 and earlier, you'll see that the new interface is a huge step up from that old monster of a form.

About half of the Android app submission form

Page one of five in the WP7 submission process

The report interfaces

When your app is published, it's time to kick back and watch the money flow in. Also here, the interfaces are good on both platforms, but I'd give Google a minor win. Google reports every single purchase with full name, date and country of the buyer, while Microsoft settles for a summary per country. Microsoft gives you a sleek graph, though - that's cool. Another thing that is a big plus for Google is the error report interface. You can actually see each single exception that occur runtime on any single phone in the world - with full stacktrace. There is no such thing at Microsoft's platform.

Since pictures says more than a thousand words:

Android Market Publish Site

Android Market main page

Detailed Sales Report

Android Market Error Report page

Android Market Error Details. Luckily I added a bug just so that I could demonstrate this feature for you!

Windows Phone App Hub

Daily download details

Daily cumulative

Data summary table per country

Sales numbers

Finally some numbers. After each application had been on the market for a month, I gathered the numbered and these are the results:

	Android	WP7
Trial	N/A	125
Full version	15	36

Both were priced at $1.

Now I think there are several reasons why I sold better at the WP7-platform. For one there is less competition there. I could not see any other apps at the time of publishing that had this kind of flag quiz. On Android there were three or four pretty similar. For free. I'm surprised I actually sold any at all.

Summary

So I'm not going to be rich on this application, but it's been a fun project. Before I leave the sales figures: I have plans to release a new version on Android (and maybe also WP7) that will be ad-based and free instead of priced at $1. I suspect I'll compete better with the other free application then, but will I make more money? It will be an interesting experiment as well, and I'll probably post a new blog entry about the results in a couple of months.

But who wins? Where will I go? I do believe it's slightly more fun to work at the WP7 platform, but the differences are not that big. Not big enough to be decisive alone. I do own a vey cool Android-based Samsung Galaxy S phone now, which is a factor that makes me want to develop for Android. I do have a WP7-device as well (on loan from Microsoft), but I actually think the Android device is slightly cooler to use and play with.

Then there is the user base, which I talked about in the introduction. The user base for Android is still quite much bigger than for Windows Phone, and that is the factor that makes me pretty sure that my next project will be on an Android device. I reach a greater audience, and that's always cool both in terms of revenue and feedback. Who want's to work for weeks in a cellar and when the day comes for publishing, you never hear a word of praise or criticism? So the next project: Android, but the next after that? Who knows - I go where the wind blows.

Dice roll comparison chart:

Aspect	Android	WP7
IDEs	4	6
APIs	4	5
Availability of documentation	6	5
Reporting functionality	5	4
Submission process	5	5
Perceived market potential	5	4
Total	29	29

It's a draw! -Everybody is happy and I'm avoiding Microsoft vs Google, Closed vs Open source-debates in the comments - perfect! :-)

Happy app developing!