I measured the time in seconds that it took to load all images without displaying them in a View. 0 Threads means that all images were loaded in a sequence. A Thread count above 0 means that I created a new AsyncTask for each image and ran n of them at the same time.

Emulator Eclair 2.1

Eclair did well in the emulator between around 3 and 40 simultaneous downloads. It became pretty critical above 50 though. When i tried 100 downloads at the same time, it just stopped to work. The app did not crash, but the downloads seemed to stop completely and no progress was visible anymore.

Emulator Gingerbread 2.3

Interestingly, the emulator with Gingerbread did way worse then Eclair, but it was OK until around 30 parallel downloads. Gingerbread even had problems to create the AsyncTasks. Even when I tried 100 parallel downloads, I could never create and run more than 75 AsyncTasks at the same time. At least the app ran until the end, but the used time for 100 parallel downloads is just beyond the acceptable.

Nexus One Gingerbread 2.3.3 (T-Mobile)

Well, the difference from the emulator to my Nexus One was impressive. I got the best result with 20 simultaneous downloads in 7 seconds, but the whole range from 3 to 50 parallel downloads was fine and never over 11 seconds. I think that is a pretty good time.

At the end I would suggest not to go over around 20 or 30 simultaneous downloads. In that way it’s still tolerable in the emulator as well as on phones with slower download rates.

It would be interesting though to see similar performance tests with other phones and carriers.

This is the OAuth workflow for Foursquare:

• A call to the Foursquare server is made with the client id and a redirect URL (has to be in a browser)
• The user accepts the access request of the application
• Foursquare calls the redirect URL with special code as parameter
• The Foursquare server has to be called again with the client id, client secret, the code and the redirect URL (not in the browser anymore)
• Foursquare returns now the access token which has to be saved by the app
• Further calls to the Foursquare API can be made with the token

The only problem in this workflow is how we can make the first call in the browser and then return to our app.

OK, we’re going to register out app first as an OAuth Consumer at Foursquare. Define the Callback URL as “simontest-android-app://”. You can do so here.

Now, we create a new Android project and give it the INTERNET permission.

Then open the Manifest file and add the following filter to the <application> tag:

<application android:icon="@drawable/icon" android:label="@string/app_name">
	<activity android:name=".LoginTest" android:label="@string/app_name">
		<intent-filter>
			<action android:name="android.intent.action.MAIN" />
			<category android:name="android.intent.category.LAUNCHER" />
		</intent-filter>

		<!-- Add this filter -->
		<intent-filter>
 			<action android:name="android.intent.action.VIEW" />
 			<category android:name="android.intent.category.DEFAULT" />
 			<category android:name="android.intent.category.BROWSABLE" />
 			<data android:scheme="simontest-android-app" />
 		</intent-filter>

 	</activity>
</application>

This maps the schema “simontest-android-app” to this activity.

Now it’s time to start the coding. Add a button or something to your UI and add a click listener to it, which calls this method:

private void loginToForsquare() {
	// Call the webbrowser with the Foursquare OAuth login URL
	Intent intent = new Intent(Intent.ACTION_VIEW);
	intent.setData(
	      Uri.parse(
	    		  "https://foursquare.com/oauth2/authenticate" +
	    		  "?client_id=" +CLIENT_ID +
	    		  "&response_type=code" +
	    		  "&redirect_uri=simontest-android-app://"));
	startActivity(intent);
}

This will open the browser where the user can accept or deny our app to access his Foursquare data. After that the browser will automatically be redirected to the Callback URL “simontest-android-app://” which we have previously mapped to our activity. The activity will be called and we can check for the expected parameter in the onResume() method:

public void onResume() {
	super.onResume();

    // extract the OAUTH access token if it exists
    Uri uri = this.getIntent().getData();
    if(uri != null) {
    	String code = null;

    	// Check if ther is a parameter called "code"
    	if((code = uri.getQueryParameter("code")) != null){

			try {
				// Call Foursquare again to get the access token
				JSONObject tokenJson = executeHttpGet(
						"https://foursquare.com/oauth2/access_token" +
						"?client_id=" + CLIENT_ID +
						"&client_secret=" + CLIENT_SECRET +
						"&grant_type=authorization_code" +
						"&redirect_uri=simontest-android-app://" +
						"&code=" + code);

				String token = tokenJson.getString("access_token");

				// TODO save token

				// Get userdata of myself
				JSONObject userJson = executeHttpGet(
						"https://api.foursquare.com/v2/" +
						"users/self" +
						"?oauth_token=" +token);

				// Get return code
				int returnCode = Integer.parseInt(userJson.getJSONObject("meta").getString("code"));

				// 200 = OK
				if(returnCode == 200){
					// output data
					Log.i("LoginTest", userJson.getJSONObject("response").getJSONObject("user").toString());
				}else{
					Toast.makeText(this, "Wrong return code: " +code, Toast.LENGTH_SHORT).show();
				}
			} catch (Exception exp) {
				Log.e("LoginTest", "Login to Foursquare failed", exp);
			}
    	}else if((code = uri.getQueryParameter("error")) != null){
    		Toast.makeText(this, code, Toast.LENGTH_SHORT).show();
    	}else{
    		Toast.makeText(this, "Unknown login error", Toast.LENGTH_SHORT).show();
    	}
    }
}

// Calls a URI and returns the answer as a JSON object
private JSONObject executeHttpGet(String uri) throws Exception{
	HttpGet req = new HttpGet(uri);

	HttpClient client = new DefaultHttpClient();
	HttpResponse resLogin = client.execute(req);
	BufferedReader r = new BufferedReader(
			new InputStreamReader(resLogin.getEntity()
					.getContent()));
	StringBuilder sb = new StringBuilder();
	String s = null;
	while ((s = r.readLine()) != null) {
		sb.append(s);
	}

	return new JSONObject(sb.toString());
}

And that is already everything. You just might wanna save the token after you’ve got it so you don’t have to login to Foursquare the next time the user starts your app.

Happy Coding!

Although the Foursquare login process is pretty easy, it took me some time to figure out how this could be done from an Android application. The problem here is, that I don’t want a Popup window for the OAuth login. There’s a different requirement for the whole login process.

A standard OAuth login process consists of this flow:

• Create consumer with application token and secret
• Get login URL from service
• Redirect the user to the login URL
• User grant or deny access to service
• Get the access token and secret

But in a mobile application, without a URL redirection, what we actually want is something like this:

• Create consumer with application token and secret
• Login to service
• Get the access token and secret

OK, first we need an OAuth library. In this example I’m going to user the Signpost lib. You can get it from here: http://code.google.com/p/oauth-signpost/

There are 3 available libraries, but for this example we need only the core and the commonshttp4 part. Then, it’s actually pretty easy to login. We can to this in just one step with the user Email-address and his password.

// Build URL and create GET request
String url = "http://api.foursquare.com/v1/authexchange" +
				"?fs_username=" +
				EMAIL +
				"&fs_password=" +
				PW;
HttpGet reqLogin = new HttpGet(url);

// Instantiate consumer with application key and secret
OAuthConsumer consumer = new CommonsHttpOAuthConsumer(
		CONSUMER_KEY,
		CONSUMER_SECRET);
consumer.sign(reqLogin);

// Login
HttpClient httpClient = new DefaultHttpClient();
HttpResponse resLogin = httpClient.execute(reqLogin);
if (resLogin.getEntity() == null) {
	throw new Exception("Could not login");
}

// Parse response
Document document =
	DocumentBuilderFactory
		.newInstance()
			.newDocumentBuilder()
				.parse(resLogin.getEntity().getContent());

// Get access token
Element eOAuthToken =
	(Element)document.getElementsByTagName("oauth_token").item(0);
Node e = eOAuthToken.getFirstChild();
String sOAuthToken =  e.getNodeValue();
System.out.println("token: " +sOAuthToken);

// Get access secret
Element eOAuthTokenSecret =
	(Element)document.getElementsByTagName("oauth_token_secret").item(0);
e = eOAuthTokenSecret.getFirstChild();
String sOAuthTokenSecret =  e.getNodeValue();
System.out.println("Secret: " +sOAuthTokenSecret);

// Set access token and secret for further requests
consumer.setTokenWithSecret(sOAuthToken, sOAuthTokenSecret);

// Get user information
HttpGet requestVenue = new HttpGet("http://api.foursquare.com/v1/user");
consumer.sign(requestVenue);
HttpResponse resVenue = httpClient.execute(requestVenue);
if (resVenue.getEntity() == null) {
	throw new Exception("Could not get user information");
}

InputStream is = resVenue.getEntity().getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line = null; 

while ((line = reader.readLine()) != null) {
    sb.append(line + "\n");
}

System.out.println(sb.toString());

Of course, this login process has to be done just once. We just need to store the access token and the secret somewhere for further use.

That’s it. Happy coding!

The same principle as described here can also be user for similar problems like setting a different background color for some items.

First we’re going to create a simple domain class with a property that describes if the item should be selectable or not.

public class MyDataObject {
    public string Name { get; set; }
    public bool IsSelectable { get; set; }
}

Next we create a XAML Window that contains a ListBox. In this ListBox we define a custom ItemContainerStyle with a Style that defines if the Item will be selected or not. And finally we bind this Style to the IsSelectable property from our data object.

And now we just have to fill the ItemsSource from the ListBox and we can run the example.

public partial class MainWindow : Window {
    public MainWindow() {
        InitializeComponent();

        myListBox.ItemsSource =
            from i in Enumerable.Range(0, 10)
            select new MyDataObject() { Name = string.Format("Object {0}", i), IsSelectable = i % 3 != 0 };
    }
}

That’s all. Easy, isn’t it?

The easiest way to revert this changes is obviously to let the user work with a copy of the real data object. So let’s add a clone method to the model and mark it as Serializable.

Model with Clone() method

[Serializable]
public abstract class PersonModel {

    public string Name { get; set; }
    public string FirstName { get; set; }
    public int Age { get; set; }

    public PersonModel Clone() {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream) {
            formatter.Serialize(stream, this);
            stream.Seek(0, SeekOrigin.Begin);
            return (PersonModel)formatter.Deserialize(stream);
        }
    }
}

We now just bind the copy of the object to the view:

myView.DataContext = person.Clone();

This copy can easily be dropped in case the user cancels the editing. In case he saves the
changes, you can just replace the original object with the copy.

One problem I ran in it was, that I normally implement the INotifyPropertyChanged interfaces to my models to inform the view about changes in the model. Unfortunately the PropertyChangedEventHandler contained in this interface causes a nasty SerializationException because the Class PropertyChangedEventManager is not marked as Serializable.

System.Runtime.Serialization.SerializationException was caught
Message=”Type ‘System.ComponentModel.PropertyChangedEventManager’ in Assembly ‘WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35′ is not marked as serializable.”

The easiest way to work around this problem is to just exclude the PropertyChangedEventHandler from the serialization.

Clonable Model that implements INotifyPropertyChanged

[Serializable]
public abstract class PersonModel : INotifyPropertyChanged {
    [field: NonSerialized]
    public event PropertyChangedEventHandler PropertyChanged;

    private string name;
    private string firstName;
    private int age;

    public string Name {
        get { return name; }
        set { name = value; OnPropertyChange(); }
    }
    public string FirstName {
        get { return firstName; }
        set { firstName = value; OnPropertyChange(); }
    }
    public int Age {
        get { return age; }
        set { age = value; OnPropertyChange(); }
    }

    public PersonModel Clone() {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream) {
            formatter.Serialize(stream, this);
            stream.Seek(0, SeekOrigin.Begin);
            return (PersonModel)formatter.Deserialize(stream);
        }
    }

    protected void OnPropertyChange() {
        string propName = new StackFrame(1).GetMethod().Name.Replace("set_", "");
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propName));
    }
}

In this way everything works fine and you have hopefully one problem less to care about…

Happy DataBinding

<?php

class MyRestService {
 /**
 * @param string $name
 * @return string
 */
 public function ping($name) {
 return 'Hello ' . $name;
 }
}

require 'Zend/Rest/Server.php';

$server = new Zend_Rest_Server ( );
$server->setClass ( 'MyRestService' );
$server->handle();

require 'Zend/Rest/Server.php';

$server = new Zend_Rest_Server ( );
$server->setClass ( 'MyRestService' );
$server->handle();

We can now allready access our service with the browser by entering the URL http://localhost/MyRestService.php?method=ping&name=Simon. The service returns the answer as XML.

<MyRestService generator="zend" version="1.0">
 <ping>
 <response>Hello Simon</response>
 <status>success</status>
 </ping>
</MyRestService>

As you can see the call as well as the answer are really straightforward and easy to unserstand. We’re going now to access our service from C#.

public void CallRest() {
 string methodName = "ping";
 string name = "Simon";

 // Build the URL with the parameters
 StringBuilder sb = new StringBuilder();
 sb.Append("http://localhost/MyRestService.php");
 sb.Append(string.Format("?method={0}", HttpUtility.UrlEncode(methodName)));
 sb.Append(string.Format("&name={0}", HttpUtility.UrlEncode(name)));

 // Download the service answer as string
 Uri address = new Uri(sb.ToString());
 WebClient serviceClient = new WebClient();
 serviceClient.DownloadStringCompleted += new DownloadStringCompletedEventHandler(serviceClient_DownloadStringCompleted);
 serviceClient.DownloadStringAsync(address);
}

private void serviceClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e) {
 try {
 // Check for service error
 if (e.Error != null)
 throw e.Error;

 // Load the result as XML for easy Linq access
 XElement elem = XElement.Parse(e.Result);

 // Check the return status
 string status = (string)(from el in elem.Descendants("status") select el).First();

 if ("success".Equals(status)) {
 // Get the response
 string resp = (string)(from el in elem.Descendants("response") select el).First();
 MessageBox.Show(resp, "The Restservice says...", MessageBoxButton.OK);

 } else if ("failed".Equals(status)) {
 // Get the error message
 string errmsg = (string)(from el in elem.Descendants("message") select el).First();
 throw new Exception(errmsg);

 } else {
 throw new Exception(string.Format("Unknown Rest status: {0}", status));
 }
 } catch (Exception exp) {
 MessageBox.Show(exp.ToString(), "Error", MessageBoxButton.OK);
 }
}

When we run the code a MessageBox with the service response should pop up.

So, this was the part I figured out quite fast. But what happens if you change the service function so somewhat like this:

/**
* @param array $names
* @return string
*/
public function ping($names){
 return $names['p2'];
}

It took me some time to figure out that the answer is quite easy. Let’s change the C# function to fit the array parameter.

public void CallRest() {
 string methodName = "ping";
 string[] names = { "Simon", "John", "Bill" };

 // Build the URL with the parameters
 StringBuilder sb = new StringBuilder();
 sb.Append("http://localhost/MyRestService.php");
 sb.Append(string.Format("?method={0}", HttpUtility.UrlEncode(methodName)));

 for (int i = 0; i < names.Length; i++)
 sb.Append(string.Format("&names[p{0}]={1}", i, HttpUtility.UrlEncode(names[i])));

 // Download the service answer as string
 Uri address = new Uri(sb.ToString());
 WebClient serviceClient = new WebClient();
 serviceClient.DownloadStringCompleted += new
 DownloadStringCompletedEventHandler(serviceClient_DownloadStringCompleted);
 serviceClient.DownloadStringAsync(address);
}

As you can see I just add the parameter as everybody would access an array. And once again, you can also access the service direct with your browser unter the URL http://localhost/MyRestService.php?method=ping&names[p0]=Simon&names[p1]=John&names[p2]=Bill

For all of them you need first a function or a class which you like to expose as service.

MyTestService.php

<?php

class MyTestService {

	/**
	 * A simple ping service
	 *
	 * @param string $value
	 * @return string
	 */
	function ping($value) {
		return $value . ' back from server';
	}
}

It is quite important to add the documentation with the exact datatype for all parameters as well as for the return value to the function. This information is used by the Zend framework to parse the values e.g. for the WSDL generation.

Rest Service

RestService.php

<?php

require 'Zend/Rest/Server.php';
require_once 'MyTestService.php';

$server = new Zend_Rest_Server();
$server->setClass('MyTestService');
$server->handle();

XmlRpc Service

XmlRpcService.php

<?php

require 'Zend/XmlRpc/Server.php';
require_once 'MyTestService.php';

$server = new Zend_XmlRpc_Server();
$server->setClass('MyTestService');
echo $server->handle();

Caution: the echo on the last line is here essential!

Soap Service

SoapWebService.php

<?php

require 'MyTestService.php';

if (isset ( $_GET ['wsdl'] )) {
	require 'Zend/Soap/AutoDiscover.php';

	$autodiscover = new Zend_Soap_AutoDiscover ( );
	$autodiscover->setClass ( 'MyTestService' );
	$autodiscover->handle ();
} else {
	require 'Zend/Soap/Server.php';

	$url = URL;
	$server = new Zend_Soap_Server ( "http://localhost/SoapWebService.php?wsdl" );
	$server->setClass ( 'MyTestService' );
	echo $server->handle ();
}

What we can see here is the possibility to generate the WSDL file automaticaly. The class Zend_Soap_AutoDiscover is doing this for us. We have just to set the class that we use as service. The WSDL is now accessible under the URL http://localhost/SoapWebService.php?wsdl.

Client

Accessing the services is as easy as creating them.

index.php

<?php

require 'Zend/Rest/Client.php';
require 'Zend/XmlRpc/Client.php';
require 'Zend/Soap/Client.php';

try {

	// Rest
	$client = new Zend_Rest_Client ( "http://localhost/RestService.php" );
	$result = $client->ping ( 'test' )->get ();
	echo 'Rest:<br/>';
	var_dump ( $result );

	// XmlRpc
	$client = new Zend_XmlRpc_Client ( "http://localhost/XmlRpcService.php" );
	$result= $client->call('ping', array('test'));
	echo '<br/><br/>XmlRpc:<br/>';
	var_dump ( $result );

	// Soap
	$client = new Zend_Soap_Client ( "http://localhost/SoapService.php?wsdl" );
	$result = $client->ping ( 'test' );
	echo '<br/><br/>Soap:<br/>';
	var_dump ( $result );
} catch ( Exception $e ) {
	echo '<b style="color:#FF0000;">Error: ' . $e->getMessage () . '</b>';
}

As you can see, the Rest- and the Soap service are a bit more intuitive to use than the XmlRpc service. Which one is best depends on the requirements and the use of the service.

<?php

class MyTestService {

/**

* A simple ping service

*

* @param string $value

* @return string

*/

function ping($value){

return $value .' back from server';

}

}

It is quite important to add the documentation with the exact datatype for all parameters as well as for the return value to the function. This information is used by the Zend framework to parse the values e.g. for the WSDL generation.

Rest Service

RestService.php

<?php

require 'Zend/Rest/Server.php';

require_once 'MyTestService.php';

$server = new Zend_Rest_Server();

$server->setClass('MyTestService');

$server->handle();

XmlRpc Service

XmlRpcService.php

<?php

require 'Zend/XmlRpc/Server.php';

require_once 'MyTestService.php';

$server = new Zend_XmlRpc_Server();

$server->setClass('MyTestService');

echo $server->handle();

Caution: the echo on the last line is here essential!

Soap Service

SoapWebService.php

<?php

require 'MyTestService.php';

if(isset($_GET['wsdl'])) {

require 'Zend/Soap/AutoDiscover.php';

$autodiscover = new Zend_Soap_AutoDiscover();

$autodiscover->setClass('MyTestService');

$autodiscover->handle();

} else {

require 'Zend/Soap/Server.php';

$url = URL;

$server = new Zend_Soap_Server("http://localhost/SoapWebService.php?wsdl");

$server->setClass('MyTestService');

echo $server->handle();

}

What we can see here is the possibility to generate the WSDL file automaticaly. The class Zend_Soap_AutoDiscover is doing this for us. We have just to set the class that we use as service. The WSDL is now accessible under the URL http://localhost/SoapWebService.php?wsdl.

Client

Accessing the services is as easy as creating them.

index.php

<?php

require 'Zend/Rest/Client.php';

require 'Zend/XmlRpc/Client.php';

require 'Zend/Soap/Client.php';

try {

// Rest

$client = new Zend_Rest_Client ( "http://localhost/RestService.php" );

$result = $client->ping('test')->get();

echo 'Rest:<br/>';

var_dump($result);

// XmlRpc

$client = new Zend_XmlRpc_Client ( "http://localhost/XmlRpcService.php" );

$result= $client->call(''ping'', array('test'));

echo '<br/><br/>XmlRpc:<br/>';

var_dump($result);

// Soap

$client = new Zend_Soap_Client("http://localhost/SoapService.php?wsdl");

$result = $client->ping('test');

echo '<br/><br/>Soap:<br/>';

var_dump($result);

} catch ( Exception $e ) {

echo '<b style="color:#FF0000;">Error: ' . $e->getMessage () . '</b>';

}



As you can see, the Rest- and the Soap service are a bit more intuitive to use than the XmlRpc service. Which one is best depends on the requirements and the use of the service.