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!

How Social Networking changes our view of privacy

As Social Networking Sites (SNS) in the Internet are faced with an exponential growth, it gets more and more important what kind of personal data users are willing to disclose to get a fully satisfying user-experience in return. These days, many users expect a SNS to allow them to broadcast their thoughts and doings in realtime to all their friends. But that was not always the case; when Mark Zuckerberg, the founder of Facebook which has currently over 400 million active users (Facebook, 2010), in 2004 invented the status field that allowed the users to make their thoughts public, many people asked him “What is that good for?” and “Why would I like to post my thoughts to the Internet?”. Since then, posting status messages has become normal for Facebook users and most of them would certainly miss that feature. These status messages are in fact nothing else then highly personal data. It is possible to know a person quite well just by reading this persons Facebook wall. But what does it mean when millions of people feel the demand to disclose their personal data to their friends and often to the whole world? Does this mean that they are less concerned about their privacy than people were previously? My research actually shows exactly the opposite of that; Even if people are sharing quite a lot of their private data, it seems that they care rather more about their privacy then in the early days.

The Term SNS is widely used these days and it may be hard to distinguish where it really applies and where not, so first of all it is important to clarify what exactly a SNS is. Boyd and Ellison (2007) defined it as

web-based services that allow individuals to (1) construct a public or semi-public profile within a bounded system, (2) articulate a list of other users with whom they share a connection, and (3) view and traverse their list of connections and those made by others within the system. The nature and nomenclature of these connections may vary from site to site.

Facebook is a perfect example of a SNS. It allows users to create a profile which they can share with their friends as an closed profile (closed to the public) or to the whole world as an open profile (open to the public). It contains a privacy settings page, which allows users to define exactly which information they want to be public and which private. Furthermore, Facebook allows users to connect their profile to a social graph consisting of their friends and family. And finally users can browse the social graph of their friends to see with whom they are friend. And of course everyone can post status messages which can, depending on the privacy settings, be seen by either just their friends or by everyone who looks at their profile.

An important point, however, is that all users have the guarantied right by law to decide themselves who can access their data. Schaefer and Birkland (2007) distinguished between four guaranteed privacy rights that are guaranteed by law: informational, physical, decision and propriety privacy. Regarding SNS the applicable one is that of informational privacy, which includes the control of personal data. With Facebook this means that all users can control who can see their personal data like name, address, Email address and also their status messages and the comments they made. Facebook does indeed provide the possibility of defining exactly who can access which information about a person. However, these are opt-out settings, which means the default is that every information is shared with everyone. If the users want their data to be private, they have to find the proper setting and change it accordingly.

Even if this privacy rights are guaranteed by law, there are exceptions that allows the FBI for example to see all information submitted through the Internet. The FBI has had the right to observe the digital data of suspects on the Internet for a long time. If they previously had a suspicion that a person did something illegal, they could request this persons data and look over it. But Batra (2008) pointed out that as reaction to the 9/11 attacks, the Patriot Act was released which now gave the FBI the right to store and even automatically analyze information gathered in the Internet. This means they do not even need a suspicion anymore to analyze someone’s data. Everybody‘s data is now automatically checked by a bunch of algorithms to see if it contains content that may be dangerous for the public. If someone, for example, writes an Email to a friend in which he complains about the government and where he writes that he would like to kill the president, the FBIs algorithms would recognize this message as potential dangerous and may alert an agent. This can lead to further observations of this person and in extreme cases even to a black listing so this person is not allowed anymore to enter the US or to fly over US territory.

Thought not just the FBI can see personal information from SNS; because of the opt-out mechanism that defines information as public by default, almost everyone with a computer can gather a lot of information about a person via a SNS. One statistic released by Lampe, Ellison and Steinfield (2008) demonstrated that about one third of the SNS users think that their profile has been watched by possible future employers and even total strangers. Of course, it brings some discomfort to know that people at the company where I just applied for a job can see the party pictures I made last weekend.

As a logical consequence of the assumption that strangers watch their profile and the fact that most SNS users know pretty well that the Internet is everything but anonymous and private, some users have started to obscure their real identity. Quan-Haase and Young (2009) showed that many users try to hide their real identity by providing some fake data or by excluding important information from their profile. The hope of this users is that by doing this, their profile won’t be that easy to find anymore or not relatable to them as person at all.

Although it’s just a minority that try to hide their identity in such a way, most of the SNS users provide their real data and do not even make use of the available privacy settings to hide their information from unknown people. Schrammel, Köffel and Tscheligi (2009) discovered that more then half of the SNS users disclose their real name as well as their picture to the public. A bit less, but still more then one third also share their date of birth and their friend connections with the world. Their profiles can therefore pretty easily be found and their data can be used or misused by anybody.

With the further evolution of SNS and the invention of Photo-services people have been faced with even more possibilities of data disclosure. Ahern, Eckles, Good, King, Naaman and Nair (2007) showed that 28% of photos that show people and were uploaded to a photo-service in the Internet were publicly accessible. Even a larger amount of non-person pictures were public; for example 64% of pictures showing activities were accessibly by everybody. They also found out that just a minority of the people are concerned about the location tagging of the pictures. With this technique, it is possible to see on a map where the users were at the moment when they took the picture. This information can, of course, easily be misused for example by a stalker to physically meet the person that took the picture.

The fact that SNS users disclose their data in such a liberal way does not mean, that they do not care about their privacy. In fact, most are very concerned about their privacy. Kasper (2005) found that 79% of adults think it is “extremity important” to be in control of their personal data. This shows the difference between the concerns of the users and what they actually do to protect their personal data. On one side, they are very concerned about their privacy but on the other side are they sharing their information quite freely.

This willingness to provide personal information despite the concern about privacy might have its roots in the unlimited confidence that especially the younger users have in the Internet. While evaluating the search behavior of people on the Internet, Conti and Sobiesk (2007) came across the interesting fact that younger people are much more likely to search for sensitive keywords, that they do not want their employer to know about, than older users. This indicates that older Internet users do not fully trust in the shallow web-anonymity while the younger ones are much more trustworthy. It also exhibits the different mentality of the users that grew up with the Internet and others that also know the time before it.

As younger users are willing to trust the Internet more and more, some of the elder people might argue that SNS and the Internet in general mislead younger generations to disclose too much private data about themselves. While the elder ones in fact just may not know how to handle these new technologis. It may be true, that younger users are willing to share more information on the internet than elders, but as showed before they are well aware that this information can be watched by other people and will therefore mostly not share any sensitive information.

This fear, that new technologies lead to a reduction in privacy, could already be seen several times in latest history. People were also very concerned about their privacy after the invention of photography, the telephone and especially in the late 1960s after the computer was invented (Kasper, 2005). As we know now, however, our privacy rights do still exist even after these inventions.

Even if the disclosing of private data in SNS can be a serious problem, we can not deny the benefits we get in response. Ferrell, Nowak and Phelps (2000) found that people actually expect personalized Marketing and that they would be upset if they lost it. This expectation can just be fulfilled if the users continue to provide some amount of private data.

References

Facebook Statistics (2010). Retrieved April 13, 2010 from http://www.facebook.com/press/info.php?statistics

Boyd, D.M., & Ellison, N.B. (2007, October). Social network sites: Definition, history, and scholarship. Journal of Computer-Mediated Communication, 13, Article 11. Retrieved April 13, 2010, from http://jcmc.indiana.edu/vol13/issue1/boyd.ellison.html

Birkland, T.A., & Schaefer, T.M. (2007). Encyclopedia of media and politics. Washington, D.C.: CQ Press. Batra, N. D. (2008). Digital freedom: how much can you handle? Lanham, Rowman & Littlefield.

Ellison, N. B., Lampe, C., & Steinfield, C. (2008). Changes in use and perception of Facebook. Computer Supported Cooperative Work (pp. 721-730). San Diego, CA: ACM. Retrieved April 13, 2010, from http://portal.acm.org.libaccess.sjlibrary.org/citation.cfm?doid=1460563.1460675

Quan-Haase, A., Young, & A.L. (2009). Information revelation and Internet privacy concerns on social network sites: a case study of facebook. Communities and Technologies (pp. 265-274). University Park, PA: ACM. Retrieved April 13, 2010, from http://portal.acm.org.libaccess.sjlibrary.org/citation.cfm?id=1556460.1556499

Köffel, C., Schrammel, J., & Tscheligi, M. (2009). Personality traits, usage patterns and information disclosure in online communities. British Computer Society Conference on Human-Computer Interaction (pp. 169-174). Cambridge, UK: British Computer Society. Retrieved April 13, 2010, from http://portal.acm.org.libaccess.sjlibrary.org/citation.cfm?id=1671031

Ahern, S., Eckles, D., Good, N.S., King, S., Naaman, M., & Nair, R. (2007). Over-exposed?: privacy patterns and considerations in online and mobile photo sharing. Conference on Human Factors in Computing Systems (pp. 357-366). San Jose, CA: ACM. Retrieved April 13, 2010, from http://portal.acm.org.libaccess.sjlibrary.org/citation.cfm?id=1240624.1240683

Kasper, D.V.S. (2005) The Evolution (Or Devolution) of Privacy. Sociological Forum, 20, 69-92. Retrieved April 13, 2010, from http://www.jstor.org/pss/4540882

Conti, G., & Sobiesk, E. (2007). An honest man has nothing to fear: user perceptions on web-based information disclosure. ACM International Conference Proceeding Series (pp. 112-121). Pittsburgh, PA: ACM. Retrieved April 13, 2010, from http://portal.acm.org.libaccess.sjlibrary.org/citation.cfm?id=1280680.1280695

Phelps, J., Nowak, G., Ferrell, E. (2000). Privacy Concerns and Consumer Willingness to Provide Personal Information. Journal of Public Policy & Marketing, 19, 27-41. Retrieved April 13, 2010, from http://www.jstor.org/stable/30000485

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.