ON Blog

Facebook, C# and ASP.NET MVC – Code samples for friends list, activities list and wall posts

onishimura — Wed, 11 Aug 2010 09:50:17 +0000

A few weeks back I wrote about the official C# SDK from Facebook and provided some sample code demonstrating how to use it to get some basic information about the logged in user. Admittedly the initial sample asp.net mvc code was fairly simple in order for it to be straight forward and easy to understand. I’ve decided to expand a bit on the sample in order to demonstrate how to use the Open graph API to perform a few more interesting calls, notably:

Post to a user’s wall
Retrieve a list of the user’s friends
Retrieve a list of the user’s activities

The original sample code demonstrated how to authenticate a user and make calls using both the official C# sdk and a home grown solution. I’ve kept that approach but have organized and refactored the samples a bit better to make it hopefully more clear. The new version of the sample code allows you to login/out to facebook only on the home page. Once logged in you can go to the ‘Official’ and ‘Custom’ tabs to view your friends, activities or to post a message to your wall. While the functionality is the same between the two tabs, the code behind them is different. I assume most people would use the official SDK but I provided an alternative just as a point of interest. OK, I was bored really, and just wanted to see how it could be done differently.

In any case, the first step before running the code is to make sure you clear any previous permissions granted to this app (or whatever app you will be using with the sample code). The login button on the home page now requests extended permissions so you’ll probably need to remove it from your list of allowed applications if you’re running the latest code with a facebook app that was using the original sample code. The actual list of permissions being request are perms=’read_stream,publish_stream,read_friendlists,user_activities’, and the full list of permissions available can be found here http://developers.facebook.com/docs/authentication/permissions.

Official C# SDK

The code to use the Facebook API can be found in the OfficialFacebookController. By default index view will simply show the name of the logged in user, which uses the same code present in the HomeController (and the original post<)

string token = HttpUtility.UrlDecode(fbConnect.AccessToken);
FacebookAPI api = new FacebookAPI(token);
JSONObject me = api.Get(“/” + fbConnect.UserID);
ViewData["Name"] = me.Dictionary["name"].String;

There are three other actions a logged in user can take here, view their friends list, view their activity list, and post a message to their wall.

Clicking the Get Friends button will call the GetFriends action in the controller. The call is simply api.Get("me/friends"), which returns a dictionary with a data key and an array of JSONObjects, representing all of the friends for the user. You could also call it with something like, api.Get("/" + fbConnect.UserID + "/friends"): "me" just uses the currently logged in user.
```
Facebook.FacebookAPI api = new Facebook.FacebookAPI(token);
JSONObject me = api.Get("/" + fbConnect.UserID);
JSONObject friendsData = api.Get("/me/friends");
var data = friendsData.Dictionary["data"];
List friendsList = data.Array.ToList();

ViewData["Name"] = me.Dictionary["name"].String;
ViewData["Friends"] = friendsList;
```
The data itself is just the name and facebook id of the user's friends, so the view just loops through the friendsList collection and displays in this format Name - Id
```
<%= friend.Dictionary["name"].String %> - <%= friend.Dictionary["id"].String %>
```
Similarly, clicking the Get Activities button will call the GetActivities controller. The code is pretty much the same as the above friends code, but calls api.Get("/me/activities");. The data is also slightly different, since the activity data contains more information (such as category, and create_date). So, the view follows pretty much the same format but displays more fields:
```
<%= activity.Dictionary["name"].String%> - <%= activity.Dictionary["id"].String%>- <%= activity.Dictionary["category"].String%>- <%= activity.Dictionary["created_time"].String%>
```
Finally, the message section allows the user to enter a message and post it to a user's wall. Entering text and clicking the Post Message button will call the PostMessage action. Instead of calling the Get method of the FacebookAPI class, we call Post:
```
Dictionary postArgs = new Dictionary();
postArgs["message"] = message;
JSONObject post = api.Post("/" + fbConnect.UserID + "/feed", postArgs);
```
The post call also returns a JSONObject which contains the id of the new post. Just for verification, we show this in the view.

Custom C# classes

The display of the custom code looks pretty much the same as the official sdk, so I won't post any images of the views. The primary classes involved are FacebookConnect.cs, FacebookObjects.cs and OpenGraph.cs. Note that compared to the original sample code I've removed the "DEMO" prefix and added a few more methods to OpenGraph, renamed the DEMOFacebookUser to FacebookObjects, and added objects to FacebookObjects.cs. These serve as the definition for our extra calls

You might also notice in FacebookObjects that the DataContract and DataMember attributes have been removed from FacebookUser. One of the more significant changes is the way in which the Call method in the OpenGraph class works. Initially it was using the DataContractJsonSerializer class, which required you to mark your class and it's properties with DataContract and DataMember attributes. However, this serializer seems to have some issues parsing certain JSON strings. So instead I've changed the code to use the JavascriptSerializer which seems to work just fine. In fact it's more flexible and seems to take less configuration than DataContractJsonSerializer, which is why it was probably undeprecated (dedeprecated?). In addition to the use of JavascriptSerializer, the Call method also takes an additional parameter to specify the type of http request made. This allows us to use the same code to make a POST request, which is necessary when writing to a user's wall. The new Call method looks like this:

private T Call(string url, string methodType) where T : class
{
	T result;
	HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
	request.Method = methodType;

	using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
	using (StreamReader reader = new StreamReader(response.GetResponseStream()))
	{
		JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
		string jsonData = reader.ReadToEnd();
		result = (T)jsSerializer.Deserialize(jsonData);
	}

	return result;
}

The various Get/Post methods in the OpenGraph class are pretty similar to the original GetCurrentUser method and rely on the objects defined in the FacebookObjects.cs file. For example, the GetCurrentUserFriends looks like the following:

public List GetCurrentUserFriends(string accessToken)
{
	string parameters = "me/friends?access_token=" + accessToken;
	string url = baseUrl + parameters;

	FacebookFriendData call = Call(url, GET);

	return call.Data;
}

The action just needs to call this method with a valid access_token. For example, the GetFriends action in CustomFacebookController, calls the following:

List friends =  openGraph.GetCurrentUserFriends(fbConnect.AccessToken);

Once this has been placed into the ViewData dictionary, we can just pull it out and iterate through it like so:

<%
	List friendsList = ViewData["Friends"] as List;
	foreach(FacebookSampleMVC2App.FacebookFriend friend in friendsList) {
%>
	<%= friend.Name %> - <%= friend.Id %>

<%  } %>

The logic/view for retrieving the user's activities and posting to the user's wall are fairly similar.

Wrap up

So there you have it, some sample code to do a bit more than just display the user's name and facebook id. The custom classes and the official sdk are pretty similar in the sense that they both just call REST methods like 'me/friends', 'me/activities' and 'me/feed' from https://graph.facebook.com/. The official SDK is more flexible however, since it doesn't need to have classes defined for each of the types, instead relying on JSONObject to wrap the dictionaries/arrays/scalars returned from the api calls.

Download the code here

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

onishimura — Thu, 29 Jul 2010 09:27:44 +0000

This is part 3 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The previous articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Download the code here

Currently our application can display a list of notes, and create and save a new note. The last piece of the puzzle is to allow the user to delete an existing note. To accomplish this all we really need to do is add an application bar button to the details page, remove it from the working items list, and save it to isolated storage.

Add the appbar.save.rest.png image in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons to the Images folder in the project, and set it’s ‘Build Action’ to Content’, and it’s ‘Copy to Output Directory’ proerpty to ‘Copy if newer’.

Change DetailsPage.xaml to include an application bar, with the following code:
```
	
		
		
	
```
The two ApplicationBarIconButton added here will allow the user to return to the main list of notes, or delete the current note being viewed.

Modify the DetailsPage class (DetaislPage.xaml.cs) to do the following

Create a private instance variable to represent the current index of current note
Change the ‘OnNavigatedTo’ method to set this index when the page gets focus
Add event handlers for the delete and back buttons

The DetailsPage class uses an index scoped to the OnNavigatedTo method, and sets the pages DataContext using it. All we really need to do is change it to an instance member and set it in OnNavigated To like so:

private int index;

protected override void OnNavigatedTo(NavigationEventArgs e)
{
	base.OnNavigatedTo(e);

	string selectedIndex = "";
	if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
	{
		index = int.Parse(selectedIndex);
		DataContext = App.ViewModel.Items[index];
	}
}

The event handlers are fairly straightforward. For the delete button, it should remove the note from the working list, save the current list to isolated storage, and finally navigate to the MainPage. The back button should simply navigate the user back to the MainPage.

private void appbar_button1_Click(object sender, EventArgs e)
{
	if (index < App.ViewModel.Items.Count)
	{
		App.ViewModel.Items.RemoveAt(index);
		StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
	}
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void appbar_button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

After all of these changes your class should look like this

using System;
using System.Collections.ObjectModel;
using System.Windows.Navigation;
using Microsoft.Phone.Controls;

namespace MyNotes
{
    public partial class DetailsPage : PhoneApplicationPage
    {
        // Constructor
        public DetailsPage()
        {
            InitializeComponent();
        }

        private int index;

        // When page is navigated to, set data context to selected item in list
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            string selectedIndex = "";
            if (NavigationContext.QueryString.TryGetValue("selectedItem", out selectedIndex))
            {
                index = int.Parse(selectedIndex);
                DataContext = App.ViewModel.Items[index];
            }
        }

        private void appbar_button1_Click(object sender, EventArgs e)
        {
            if (index < App.ViewModel.Items.Count)
            {
                App.ViewModel.Items.RemoveAt(index);
                StorageHelper.Save>(App.NotesFileName, App.ViewModel.Items);
            }
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }

        private void appbar_button2_Click(object sender, EventArgs e)
        {
            NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }
    }
}

And thats it. We can now add a new note, view a list of current notes and delete an existing note. This note app for Windows Phone 7 is fairly simple in functionality, so naturally there’s many more features you can add. For example, we could allow the editing of notes, or the addition of different types of notes, such as sketches. I’ve added the completed project below.

Download the code here

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

onishimura — Tue, 27 Jul 2010 09:19:50 +0000

This is part 2 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

In part one of the tutorial we created the project, added a new Note class to serve as our model, and added a StorageHelper class to help us manage IsolatedStorage. The next step is to add support for adding a note to the app. We’ll keep it simple and just use a button on the main page’s application bar to add a note. When a user clicks the add note button on the main page, a new Windows Phone 7 page will load, which will enable the user to enter a note title and note text. They’ll also be able to save the note, or cancel the save, which will return them to the main page.

Add default icons to the project in order to support adding a note, saving a note and canceling the action. When you install the Windows Phone 7 SDK it also installs a number of default icons in C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons. For our purposes we’re going to use the icons in the dark folder, specifically add the following to the Images folder:
- appbar.add.rest.png
- appbar.save.rest.png
- appbar.cancel.rest.png
After adding these icons, modify their properties so that their Resource type is Content and Copy to output directory is ‘Copy if newer’. This allows us to configure the IconUri property on the ApplicationBarIconButton to a path like the following: IconUri=”/Images/appbar.add.rest.png”.
Modify MainPage.xaml and MainPage.xaml.cs to do the following:
- Display the notes properly
- Add a new application bar button
- An event handler for the button’s click
- Refresh the list of displayed notes whenever the page is navigated to. This will allow the user to see the new notes that they’ve added.
In MainPage.xaml change the StackPanel in MainListBox to the following:
```
   
   
```
This allows the notes to be displayed on the main page, displaying the note’s title and createdate. Now add the following application bar before the closing phone:PhoneApplicationPage tag
```
   
        
   
```
This will add our appbar button and use the add icon we added earlier as it’s image. Next we change MainPage.xaml.cs to handle the app bar button’s click event. First add an event handler:
```
        private void appbar_button1_Click(object sender, EventArgs e)
        {
            // Navigate to the new page
            NavigationService.Navigate(new Uri("/AddPage.xaml", UriKind.Relative));

            // Reset selected index to -1 (no selection)
            MainListBox.SelectedIndex = -1;
        }
	
```
This simply uses the base navigation framework in the windows phone 7 version of silverlight to navigate the user to the AddPage page, which we’ll add in a bit. Now modify the OnNavigatedTo method to refresh the data list whenever the page gets focus
```
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            if (DataContext == null)
                DataContext = App.ViewModel;

            App.ViewModel.Refresh();
            MainListBox.ItemsSource = App.ViewModel.Items;
        }
	
```
Modify MainViewModel.cs to add a Refresh method that will set the ViewModel’s current Items property to the latest data in isolated storage. All we really need to do is call the Load method in our StorageHelper class
```
public void Refresh()
{
    Items = StorageHelper.Load>(App.NotesFileName);
}
```
Also, remove the code in the MainViewModel.cs constructor that initializes the ObservableCollection of ItemViewModels. The Refresh method will be called by the MainPage’s OnNavigateTo method (which is also called when the page is first displayed)

Finally, add a new Silverlight xaml page, AddPage.xaml and configure it with Silverlight controls (textblocks and textboxes) for title and note. Additionally, add the application bar items to the AddPage.xaml file for saving and canceling, and modify AddPage.xaml.cs to handle the click events

The xaml for AddPage.xaml should look like the following. Note that we’re using the save and cancel icons we added earlier, for the application bar

The code behind for this page really only needs two events added to it, to save the note and navigate back to the main page, and to navigate back to the main page when the user clicks ‘cancel’

private void button1_Click(object sender, EventArgs e)
{
	Note newNote = new Note { Title = textTitle.Text, NoteText = textNote.Text, CreateDate = DateTime.Now };
	newNote.Save();

	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

private void button2_Click(object sender, EventArgs e)
{
	NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
}

And thats it! We should now be able to add a note to our notes.dat file, and view the new note in a list of notes on our main page. As you can see adding controls and event handlers in silverlight and windows phone 7 is quick and easy. Next up, deleting a note…..

Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 1

onishimura — Sun, 25 Jul 2010 08:24:28 +0000

This is part 1 in a 3 part tutorial for creating a notes application using Silverlight and Windows Phone 7. The other articles can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 3

Admittedly a bouncing ball on Windows Phone 7 isn’t all that useful, so I decided to create a sample application that could do a little more than draw a ball or say ‘hello world’. Ideally I wanted to work with some of the core concepts on the phone, such as lists, navigation and the application bar. Additionally I wanted a Windows Phone 7 app that persisted it’s data, which meant working with Isolated Storage. Obviously this calls for a note-taking app…after all who doesn’t love taking notes? Notes are only second to bouncing balls in my book.

To keep the scope of the app small and focused, I wanted the note app to do only the following

View a list of notes
Add a note
Delete a note

Pretty simple, right? The actual implementation turned out to be fairly quick as well. The full step by step is a little long for a single blog post so I’m breaking it up into three posts. The first post covers creating the project, adding a support class to help manage the isolated storage, and defining the model. The second post will cover adding a note, and the third post will cover deleting a note.

To start with, create a Windows Phone List Application, named MyNotes. This will create a basic silverlight template for managing list-based apps. The structure of the project follows the MVVM pattern, so the views are populated by ViewModel classes, defined in the ViewModel folder.

Here’s a quick run down of the files in the base list project:
- MainPage.xaml : The initial screen of the site, which displays data in a ListBox named MainListBox by default. Selecting an item fires the MainListBox_SelectionChanged which navigates the user to the details page
- DetailsPage.xaml : Individual item details for each item in the list. Clicking on an item on the main page brings you here
- MainViewModelSampleData.xaml : Just as the name states, sample data that’s displayed during design time. Basically allows the design surface to render with the xaml designer.
- MainViewModel.cs : ViewModel for the MainPage, by default the project populates itself with dummy “runtime” data when the project is run. The application has a property, ViewModel, which is an instance of this class and used in both the main page and details page to show the items.
- ItemViewModel.cs : ViewModel for each individual item in the list. This default class has really only three properties, LineOne, LineTwo, LineThree, but also demonstrates an implementation for INotifyPropertyChanged

Create a helper class to save notes data. Local data storage using silverlight in Windows Phone 7 is currently limited to using isolated storage. There’s no limit on the amount of data that can be stored though, other than the physical limit of the device of course. I’ve used something similar to the following in the past (This uses System.Runtime.Serialization so you’ll have to add that as a reference):

using System.IO.IsolatedStorage;
using System.Runtime.Serialization;

namespace MyNotes
{
    public class StorageHelper
    {
        public static T Load(string name) where T : class, new()
        {
            T loadedObject = null;
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.OpenOrCreate, storageFile))
            {
                if (storageFileStream.Length > 0)
                {
                    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                    loadedObject = serializer.ReadObject(storageFileStream) as T;
                }
                if (loadedObject == null)
                {
                    loadedObject = new T();
                }
            }

            return loadedObject;
        }

        public static void Save(string name, T objectToSave)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            using (IsolatedStorageFileStream storageFileStream = new IsolatedStorageFileStream(name, System.IO.FileMode.Create, storageFile))
            {
                DataContractSerializer serializer = new DataContractSerializer(typeof(T));
                serializer.WriteObject(storageFileStream, objectToSave);
            }
        }

        public static void Delete(string name)
        {
            using (IsolatedStorageFile storageFile = IsolatedStorageFile.GetUserStoreForApplication())
            {
                storageFile.Remove();
            }
        }
    }
}

Instead of using the ItemViewModel class, we’re going to add our own Model, Note. This requires us to make changes in MainPage.xaml, MainViewModel.cs, DetailsPage.xaml and MainViewModelSampleData.xaml as well, to reflect the new properties. So, create a new folder title Models, and add the Note class below, to it. Also, change all references from ItemViewModel to Note, as this will be the Model we’ll be using going forward (I just did a find and replace on the entire project).

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.Serialization;

namespace MyNotes
{
    [DataContract]
    public class Note : INotifyPropertyChanged
    {
        private string title;
        [DataMember]
        public string Title
        {
            get
            {
                return title;
            }
            set
            {
                if (value != title)
                {
                    title = value;
                    NotifyPropertyChanged("Title");
                }
            }
        }

        private string noteText;
        [DataMember]
        public string NoteText
        {
            get
            {
                return noteText;
            }
            set
            {
                if (value != noteText)
                {
                    noteText = value;
                    NotifyPropertyChanged("NoteText");
                }
            }
        }

        private DateTime createDate;
        [DataMember]
        public DateTime CreateDate
        {
            get
            {
                return createDate;
            }
            set
            {
                if (value != createDate)
                {
                    createDate = value;
                    NotifyPropertyChanged("CreateDate");
                }
            }
        }

        public void Save()
        {
            ObservableCollection currentNotes = StorageHelper.Load>(App.NotesFileName);
            currentNotes.Add(this);
            StorageHelper.Save>(App.NotesFileName, currentNotes);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (null != handler)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

For xaml files, such as MainViewModelSampleData.xaml you’ll need to change the properties that are bound, for example

Modify your App.xaml.cs file to add the following property. This is just the name of the notes file that will be stored in isolated storage.
```
	public static string NotesFileName
	{
		get { return "notes.dat"; }
	}
```

So now we have a fairly simple starting point. We have a main page, a details page, a class to help us manage isolated storage, and our base model class, Note. Next up, adding a note…

Part 2 is now up and can be read here
Windows Phone 7 Tutorial – Creating a simple notes app with Silverlight Part 2

Windows Phone 7 – List of Tutorials and Resources

onishimura — Thu, 22 Jul 2010 08:11:41 +0000

Following up on yesterday’s post on Windows Phone 7 development, here’s a few of the tutorials and guides I’ve been looking at the past few days. There’s a lot of info to digest so I’ll be adding to this post as I come across more resoucres.

Tutorials and Samples

Scott Guthrie’s Tutorial
http://weblogs.asp.net/scottgu/archive/2010/03/18/building-a-windows-phone-7-twitter-application-using-silverlight.aspx
Introduction to Silverlight on Windows Phone 7 – Creating a list application
http://10rem.net/blog/2010/03/15/building-your-first-silverlight-for-windows-phone-application
Introduction to XNA
http://mobile.tutsplus.com/tutorials/windows/introduction-to-xna-on-windows-phone-7/
Channel 9 Developer Training Kit
http://channel9.msdn.com/learn/courses/WP7TrainingKit/
Code Samples for Windows Phone
http://msdn.microsoft.com/en-us/library/ff431744(VS.92).aspx
Charles Petzold’s Free ebook
http://blogs.msdn.com/b/microsoft_press/archive/2010/03/15/free-ebook-programming-windows-phone-7-series-draft-preview.aspx

Blogs/Community

Windows Phone Developer Blog
http://windowsteamblog.com/Windows_Phone/b/wpdev/
Smarty Pants Coding
http://www.smartypantscoding.com/
Nick Gravelyn’s Blog – Focused on the XNA Framework and game development
http://blogs.msdn.com/b/nicgrave/
Jesse Liberty – Check out the mini-tutorials
http://jesseliberty.com/Tags/phone/
Paul Thurrott
http://windowsphonesecrets.com/
Windows Phone 7 Forums
http://social.msdn.microsoft.com/Forums/en-US/windowsphone7series/threads

Documentation and Resources

Official Developer Portal
http://developer.windowsphone.com/
Class Library Reference
http://msdn.microsoft.com/en-us/library/ff626516(v=VS.92).aspx
Programming Guide for Windows Phone
http://msdn.microsoft.com/en-us/library/ff402551(v=VS.92).aspx
Developer Tools Resouces – Getting started and Developer Fundamentals
http://msdn.microsoft.com/en-us/library/ff402523(v=VS.92).aspx
Design Resources
http://msdn.microsoft.com/en-us/library/ff637515(VS.92).aspx
Windows Phone 7 Jump Start Training Resources
http://borntolearn.mslearn.net/wp7/m/classresources/default.aspx

Windows Phone 7 and Silverlight – Getting started with a Bouncing Ball

onishimura — Tue, 20 Jul 2010 23:55:36 +0000

The beta of the developer tools for Windows Phone 7 was released last week. I was curious to see how different/easy it was to develop for this platform so I decided to convert my old SL 3 bouncing ball app, done AGES ago, to Silverlight 4 and Windows Phone 7. The process was pretty painless and even allowed me to add a few features:

1. Install the tools from http://www.microsoft.com/downloads/details.aspx?FamilyID=c8496c2a-54d9-4b11-9491-a1bfaf32f2e3&displaylang=en if you haven’t already

2. Create a new Windows Phone Application (from templaes: Visual C# – Silverlight for Windows Phone – Windows Phone Application)

3. Modify the ContentGrid, change it to a canvas and add an ellipse:

4. Uncomment the sample app bar code and change it to the following, to add a click event and some descriptive text:

5. In the code behind add the following private instance variables, which are used to determine the initial speed of the ball and the current state of the ball:

private int xVelocity = 5;
private int yVelocity = 5;
private bool isBouncing = false;

6. Add a helper method to start a new bounce, randoming the directions and speed:

private void startNewBounce()
{
	//Make speed, direction random
	Random r = new Random();
	xVelocity = r.Next(3, 10);
	yVelocity = r.Next(3, 10);
	int coin = r.Next(100);
	if (coin > 50)
	{
		xVelocity *= -1;
	}
	coin = r.Next(100);
	if (coin > 50)
	{
		yVelocity *= -1;
	}

	ellipseStoryboard.Begin();
	isBouncing = true;
}

7. Add the storyboard_Completed event. This will move the ellipse and also check for collisions against the layoutroots dimensions. If a collision is found it will reverse the direction. Note that the Y axis is a little funnky here, I had to tweak the upper and lower bounds a bit, partially because of the space the title grid takes up.

protected void ellipseStoryboard_Completed(object sender, EventArgs e)
{
	double ellipseX = (double)ellipseObject.GetValue(Canvas.LeftProperty);
	double ellipseY = (double)ellipseObject.GetValue(Canvas.TopProperty);

	//NOTE: canvas.width - ellipse.width for max, since the left and top properties
	//are based on upper left corner of the object
	//+/- 250 if title is present
	if (ellipseX >= (LayoutRoot.ActualWidth - ellipseObject.ActualWidth) || ellipseX <= 0)
	{
		xVelocity *= -1;
	}
	if (ellipseY >= ((LayoutRoot.ActualHeight - 300) + ellipseObject.ActualHeight) || ellipseY <= -150)
	{
		yVelocity *= -1;
	}

	ellipseX += xVelocity;
	ellipseY += yVelocity;

	ellipseObject.SetValue(Canvas.LeftProperty, ellipseX);
	ellipseObject.SetValue(Canvas.TopProperty, ellipseY);

	ellipseStoryboard.Begin();
}

8. Add an event handler for the app bar button click. All we need to do is start a new bounce (if the ball is already moving this will change the speed/direction of the ball too):

private void appbar_button1_Click(object sender, EventArgs e)
{
	startNewBounce();
}

9. One last piece of functionality, add a start/stop toggle if the user touches the screen. On the emulator this boils down to basically clicking the mouse on the screen. The events used to detect touch inputs are OnManipulationStarted, OnManipulationDelta and OnManipulationComepleted.

protected override void OnManipulationStarted(ManipulationStartedEventArgs e)
{
	base.OnManipulationStarted(e);
	if (isBouncing)
	{
		ellipseStoryboard.Stop();
		isBouncing = false;
	}
	else
	{
		ellipseStoryboard.Begin();
		isBouncing = true;
	}

}

10. Hit f5 and let the emulator load up, it could take a bit but even on my old machine it wasn't too bad. A lot faster than the Android emulator in Eclipse was at least.

The fact that the development language and environment is pretty much the same is compelling. There are some differences though. Debugging in the emulator worked failry well too, clicking on the home button would stop the debugging process but leave the emulator running. Performance on the emulator wasn't fantastic but I guess that's to be expected. Just means I need to get a new computer. As I mentioned I did have to make some adjustments in the collision detection code to account for the title, but there's still a small bar at the top of the emulator that makes it look like the ball isn't hitting the exact top. It might look better on an actual device though, tough to say without having a device to test on.

Download the code here

Facebook C# – Sample ASP.NET application and access tokens

onishimura — Mon, 19 Jul 2010 08:05:58 +0000

Put together another quick sample app, this time for ASP.NET 4.0, instead of MVC.
I’ve also added an example of how to post to a user’s wall, using the Facebook C# SDK

As I mentioned earlier, the facebookconnect class included is just a helper class I used to pull values out of the fbs_[appid] cookie. You can get the access_token out of the cookie directly if you want using something like the following:

string accessToken = HttpContext.Current.Request.Cookies["fbs_" + ConfigurationManager.AppSettings["AppID"]]["\"access_token"];

Assuming you have AppID as an appsetting in your web.config. Also, as usual you should change the app id in the sample project to match whatever your current app is using.

Download the code here

Official Facebook C# SDK Released

onishimura — Sat, 17 Jul 2010 05:53:11 +0000

Looks like a brand new SDK to play with for facebook. While they have other sdks for python, php, javascript, etc, this is their first official C# SDK. Previously the primary SDK that was available was the Facebook Developers Toolkit, which hasn’t been updated in some time (and hasn’t been updated to support the open graph api as far as I can tell).

You can grab the code from github at http://github.com/facebook/csharp-sdk.

One interesting thing to note, the current alpha build doesn’t provide a method to get an access token for the current user. The access token allows you to perform authorized requests on behalf of a user, and can be obtained via a redirect from Facebook, after the user has authenticated themselves. Without that token you can only access public data for a given user. The code is fairly simple in that case (this is taken directly from the console sample application on github):

string token = null;
Facebook.FacebookAPI api = new Facebook.FacebookAPI(token);
JSONObject me = api.Get("/4");
Console.WriteLine(me.Dictionary["name"].String);

Essentially, when you pass in a null token you can only access a user’s public data by passing in the user’s Facebook ID. 4 is apparently Mark Zuckerberg’s FB ID, makes me wonder who the first three were.

In any case, the lack of a way to obtain a user’s access_token makes sense since the SDK is meant to be used in multiple types of apps. This sounds like an opportunity to write some code, YAY! I’ve actually already detailed some of this previously.

Retrieving the access_token is pretty straightforward, since it’s available in a cookie that the user gets after authenticating. The name of this cookie is fbs_[AppID], where [AppID] is whatever application id facebook assigned to you. I’ve created a sample ASP.NET MVC 2 application that demonstrates this. It uses a simple wrapper class (FacebookConnect) to pull out the access_token for the currently logged in user, available as a property. Once you have the access_token you can then make authorized requests for the user:

FacebookConnect fbConnect = new FacebookConnect();
if (fbConnect.IsConnected)
{
    Facebook.FacebookAPI api = new Facebook.FacebookAPI(fbConnect.AccessToken);
    JSONObject me = api.Get("/" + fbConnect.UserID);
    name = me.Dictionary["name"].String;
}

I did run into an issue when setting the access_token on the FacebookAPI object. When the url is constructed it passes the Dictionary to an EncodeDictionary method (line 205 in FacebookAPI.cs), which encodes the key-value pairs using the HttpUtility.UrlEncode method. This caused problems when making calls to the graph, specifically an OAuthException : Invalid OAuth access token. Calls typically look like the following url (note that I’ve personally tweaked these urls so they wont actually work now, I’ve listed them just to demonstrate the issue):

https://graph.facebook.com/727440495?access_token=132568260112276|2.Z_FaL6rzoNMt2D3jfnEaWP__.3600.1279345500-727440495|77SIciuK333BmipPho0EIdJ8bwl.

or, after encoding

https://graph.facebook.com/727440495?access_token=132568260112276%7C2.Z_FaL6rzoNMt2D3jfnEaWP__.3600.1279345500-727440495%7C77SIciuK333BmipPho0EIdJ8bwl.

After the call to the EncodeDictionary method the url looks like this:

https://graph.facebook.com/727440495?access_token=132568260112276%257C2.Z_FaL6rzoNMt2D3jfnEaWP__.3600.1279345500-727440495%257C77SIciuK333BmipPho0EIdJ8bwl.

The pipe character in the original url is being double encoded to %257C. So when you try calling this url you get this returned:

{
   "error": {
      "type": "OAuthException",
      "message": "Invalid OAuth access token."
   }
}

The web exception thrown in the project is slightly more vague “The remote server returned an error: (400) Bad Request.”

For the time being I’ve just modified the FacebookAPI.cs class in the project to check for “access_token”, and skip encoding if an access token is passed in, though I guess another solution could be to just make sure you UrlDecode any access token you pass into the constructor:

if (kvp.Key.ToLower() == "access_token")
{
	sb.Append(kvp.Value);
}
else
{
	sb.Append(HttpUtility.UrlEncode(kvp.Value));
}

A couple of other things to note:
1. This is a MVC 2 web app, in Visual Studio 2010
2. You need to set your app id in the web.config file
3. I’ve also included two classes that I’ve used on previous projects to make calls to the open graph api, DEMOOpenGraph and DEMOFacebookUser. These use a DataContract and the DataContractJsonSerializer class to populate a strongly typed object. Below is some sample code showing it’s use:

OpenGraph graph = new OpenGraph();
facebookUser = graph.GetCurrentUser(FacebookConnect.AccessToken);
string firstName = facebookUser.First_Name;

This is obviously less flexible than the dictionary that the official API uses
4. You should also set the AppID value in web.config to your own value, I’ve left my own sample appid in there.

Download the code here

UPDATE
I’ve reworked the sample and provided a description for some of the new functionality here

http://onishimura.com/2010/08/11/facebook-c-and-asp-net-mvc-code-samples-for-friends-list-activities-list-and-wall-posts/

Fixing Facebook IE problems

onishimura — Wed, 14 Jul 2010 20:52:49 +0000

A friend of mine ran into this IE problem recently and it reminded me of one of the early snags I hit when developing a facebook application with the Open Graph API. IE is much more finicky about cross domain requests than other browsers, which can cause issues when authenticating with Facebook. The primary symptom of this problem is that a user can login to your site using the Facebook login button and firefox or chrome, but cannot log in via IE. The trick is that you need to also set the Base Domain field to handle multiple subdomains. So, if your Connect URL was http://www.somesite.com/, you’d set your Base Domain field to somesite.com.

Other problems indicative of cross domain issues are blank login popups or callbacks never being called (such as getLoginStatus). For my projects, setting the Base Domain fixes these issues. I typically use xd_receiver.htm as a default channel file, but you can also create your own channel file and pass it in during initialization using the channelUrl property of FB.init (e.g. http://wiki.github.com/facebook/connect-js/custom-channel-url).

Another error that might occur is ‘HTTP Error 400 – Bad Request’, after authentication. The login popup appears normally when the user clicks the fb:login button, but after successfully authenticating, the server returns a 400 error code. This typically happens if you’re developing locally with visual studio and using cassini as your development web server. Usually when debugging the url will have the form ‘localhost:8111′. There seems to be an issue with facebook’s javascript when a port number is specified, but it only pops up when testing IE, chrome and firefox are fine.

Note that all of this assumes you have the Connect URL set properly. If that’s not set to the correct domain/url, you’d get the following error:

Invalid Argument
The Facebook Connect cross-domain receiver URL (http://dev.somesite.com/home?fb_xd_fragment#?=&cb=f1077766447d60a&relation=opener&transport=fragment&frame=f15982ca8deeee5&result=xxRESULTTOKENxx) must have the application’s Connect URL (http://dev.somesite.com/) as a prefix. You can configure the Connect URL in the Application Settings Editor.

Converting a Facebook Connect site to Open Graph step by step

onishimura — Mon, 07 Jun 2010 09:09:53 +0000

A few weeks back I decided to upgrade one of my web apps to the Open Graph API. Previously it was running on Facebook Connect and using the Facebook Developers Toolkit on the backend. This still works fine, but it always felt like over kill. The simplicity of the new Open Graph api is compelling, and implementing it was pretty straight forward.

Remove code to initialize the connect javascript library
This includes the link to the FeatureLoader script and the javascript used to initialize the library. In my case the code looked like this:
```
FB_RequireFeatures(["XFBML"], function(){
	FB.init('APIKEY', 'Path to xd_receiver.htm',{permsToRequestOnConnect : 'email'});
});
```
The above code is not compatible with the Javascript SDK or any of the social widgets.
Add the open graph namespace to your Master page’s html element

Load the library asynchronously in the master page with the following code, by placing this right after the opening body tag. Be sure to enter a valid app id where ‘your app id’ is listed.


window.fbAsyncInit = function() {
	FB.init({appId: 'your app id', status: true, cookie: true, xfbml: true});
		/* sample events to respond to*/
		FB.Event.subscribe('auth.login', function(response) {});
		FB.Event.subscribe('auth.logout', function(response) {});
		FB.getLoginStatus(function(response) {});
	 };
(function() {
	var e = document.createElement('script'); e.async = true;
	e.src = document.location.protocol +
	  '//connect.facebook.net/en_US/all.js';
	document.getElementById('fb-root').appendChild(e);
}());

Depending on whether or not you’re using the XFBML elements, you may have to remove modify these elements to remove missing attributes (for example, the fb:login-button element). In my case I use the javascript SDK to login with the following jquery :
```
$('#fbLogin).live('click',function() {
	FB.login(function(response) {
	  if (response.session) {
		//user has been authenticated
	  } else {
	  }
	}, {perms:'email,user_about_me'});
	return false;
});
```
Modify your logout code to use FB.logout, for example:
```
FB.logout(function(response) {
  //whatever code you want to run when the user logs out
});
```
Again if you’re using XFBML you can just set your login buttons autologoutlink attribute to true.

That’s pretty much all there is to it, much simpler than implementing the original Connect code. Making calls to the Open Graph API on the backend is a bit more involved. While I initially used the Facebook Developer toolkit, I’ve since removed that dependency entirely, and created wrapper classes to pull out the necessary keys from the authentication cookie (namely sessionkey and access_token) to make the necessary calls. If there’s any interest in it I can post that code and a few examples of using it.