Launch Visual Studio 2010 Express, and open the previously created Tasks project.

Double-click MainPage.xaml in Solution Explorer, and add a text box and a button to the design surface, as shown in Figure 10-2. Clear the Text property of the text box, and set the button's caption to "Launch Browser."

Add the following using directive to the top of MainPage.xaml:

using System.Diagnostics;

You will launch the web browser when the user clicks the Launch Browser button. Double-click the Launch Browser button on MainPage.xaml, and make that button's Click event handler look like the following:

private void button2_Click(object sender, RoutedEventArgs e)
{
        WebBrowserTask webTask = new WebBrowserTask();
        webTask.Show();
        webTask.URL = "http://www.windowsphone.com";
}

The application life cycle events discussed in the previous section are all automatically stubbed out (in other words, they contain basic method signatures without any implementation logic) in the App.xaml.cs file. Open that file (one way to do it is to right-click App.xaml and select View Code) so that you can modify those events by adding tracing logic to them.

Within the Application_Launching event, add the following line of code:

Debug.WriteLine("Application Launching");

Within the Application_Activated event, add the following line of code:

Debug.WriteLine("Application Activated");

Within the Application_Deactivated event, add the following line of code:

Debug.WriteLine("Application Deactivated");

Within the Application_Closing event, add the following line of code:

Debug.WriteLine("Application Closing");

When the application first comes up, observe how an Application Launching message is printed in the Output window, indicating that the Application_Launching event has fired, but the Application_Activated event has not fired upon the initial launch of an application.

Click the Launch Browser button to bring up Internet Explorer with the Windows Phone web site open. In the Visual Studio Output window, notice how the Application_Deactivated event fired as soon as the web browser was launched (see Figure 10-3), indicating possible tombstoning of your application.

Click the Back button on the emulator screen. Notice how the Application_Activated event fires and prints a message in the Output window.

Click the Start button, and observe how Application_Deactivated is fired again. If you click the Back button now, the Application_Activated event is triggered.

Finally, click the Back button again. Since you have navigated past the first page of the application, the application is terminated, triggering the Application_Closing event and printing the corresponding message in the Output window.

Launch Visual Studio 2010 Express, and open the previously created Tasks project, if it's not already open.

Open MainPage.xaml.cs (one way is to right-click MainPage.xaml and select View Code). You will add code to save text entered in the text box on MainPage.xaml into the session objects if the page becomes no longer active in a frame—i.e., in that page's OnNavigatedFrom method. Add the following code to the MainPage.xaml.cs file:

protected override void
OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
                {
                        Debug.WriteLine("Navigated From MainPage");

                        if (State.ContainsKey("TextboxText"))
                {
                                State.Remove("TextboxText");
                }
                        State.Add("TextboxText", textBox1.Text);
                        base.OnNavigatedFrom(e);
                }

Notice the use of the State dictionary object—it is indeed very similar to the Session variable of ASP.NET web-based applications, and in the previous method you add the value from the text box into the State dictionary object.

Next, you will add code to retrieve values from the State dictionary object when the user navigates to the current page; you will do that inside the OnNavigatedTo method:

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs
e)
        {
                Debug.WriteLine("Navigated To MainPage");

                if (State.ContainsKey("TextboxText"))
                {
                        string strTextboxText = State["TextboxText"] as string;

                        if (null != strTextboxText)
                                textBox1.Text = strTextboxText;
                }

                base.OnNavigatedTo(e);
        }

Add the following two using directives to the top of the MainPage.xaml.cs file:

using System.IO.IsolatedStorage;
using System.IO;

You will add code to save text into the isolated storage area of your application if the user presses the Back button past your application's first page (for example, the user presses the Back button as soon as the application launches). If you would like to get more familiar with isolated storage, see Chapter 13. Add the following method to the MainPage.xaml.cs file:

protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs
e)
              {
                      base.OnBackKeyPress(e);
                      MessageBoxResult res = MessageBox.Show("Do you want to save your work
before
                      leaving?", "You are exiting the application",
              MessageBoxButton.OKCancel);

                      if (res == MessageBoxResult.OK)
                      {
                              Debug.WriteLine("Ok");
                              SaveString(textBox1.Text, "TextboxText.dat");
                      }
                      else
                      {
                              Debug.WriteLine("Cancel");
                      }
              }

Notice how the message box is used to ask the user whether to save information to the file inside isolated storage; if the user chooses Yes, the SaveString method is called, passing the value to save and the file to save it to.

Finally, you need to code the SaveString method that performs all the heavy lifting saving data to the isolated storage. This method accepts the name of the file as one of the parameters, and then it creates a file with that name within the isolated storage. After the file is created, the method saves the data string passed to it inside that file. While persisting string values inside the file is perfectly acceptable for the small application that you are building in this demo, you might consider a different data structure for bigger production applications with lots of data to persist. Serializing data to XML would be a better alternative for such applications, as would be saving data inside a dictionary or key-value collection objects. Here is the full listing of the method to persist data to an isolated storage; make sure it is also present in your code.

Invoke data initialization and retrieval on a separate thread so as to maximize the responsiveness of an application.

Perform application initialization inside the OnNavigatedTo method of the PhoneApplicationPage class.

In this demo, you will add the necessary methods to properly load application data from the isolated storage.

You will continue modifying the Tasks project that you have worked with throughout this chapter. At the top of MainPage.xaml.cs, add the following using directive:

using System.Threading;

Open MainPage.xaml.cs and go to the OnNavigatedTo method within that code. You will make adjustments to that method to load data asynchronously (on a separate thread) from the isolated storage, if there is no data in the State dictionary. If you recall, the State dictionary object is used to hold transient application data, or data that is being saved and retrieved as the user navigates between pages in the application. Therefore, you check the State object to determine whether transient or permanently persisted data should be retrieved. Make the OnNavigatedTo method look like the following:

protected override void
OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
                   {
                        Debug.WriteLine("Navigated To MainPage");

                        if (State.ContainsKey("TextboxText"))
                        {
                                string strTextboxText = State["TextboxText"] as string;

                                if (null != strTextboxText)
                                textBox1.Text = strTextboxText;
                        }
                        else
                        {
                                LoadAppStateDataAsync();
                        }

                        base.OnNavigatedTo(e);
                   }

The LoadAppStateDataAsync method is responsible for invoking a method that accesses isolated storage data on a separate thread. The full method is shown here:

public void LoadAppStateDataAsync
{
     Thread t = new Thread(new ThreadStart(LoadAppStateData));
     t.Start();
}

Finally, the LoadAppStateData method accesses isolated storage data looking for a particular file (hardcoded to be TextboxText.dat at the moment) and the settings within that file.

public void LoadAppStateData()
               {

string strData = String.Empty;

                        //Try to load previously saved data from IsolatedStorage
                        using (IsolatedStorageFile isf =
IsolatedStorageFile.GetUserStoreForApplication())
                        {
                                //Check if file exits
                                if (isf.FileExists("TextboxText.dat"))
                                {
                                        using (IsolatedStorageFileStream fs =
isf.OpenFile("TextboxText.dat",
                                        System.IO.FileMode.Open))
                                        {
                                                        using (StreamReader reader = new
StreamReader(fs))
                                                        {
                                                                strData = reader.ReadToEnd();
                                                        }
                                        }
                                }
                        }
                        Dispatcher.BeginInvoke(() => { textBox1.Text = strData; });
                  }

Your application is now complete, and it should handle both transient and persistent states. To test it, press F5 and enter "Hello, world" in the text box presented. Next, press the Back button and answer Yes to save work before leaving. The application is now terminated; if you press F5 again to re-launch the application, the screen should come with "Hello, world" already populated within it.

Launch Visual Studio 2010 Express, and open the previously created Tasks project.

Double-click MainPage.xaml in Solution Explorer, and add a button to the design surface, somewhere underneath the other two buttons. Set the name of the button to be btnFacebook and set the button's caption to "Post to Facebook."

Right-click on the project name (Tasks) in the Solution Explorer and choose Add

Double-click the newly added FBLogin.xaml page in Solution Explorer and add a web browser control to that page. Make the web browser control occupy the whole width and height of the page, since the user will be utilizing this control to log in to Facebook.

First things first—you need to add a couple of references to the project to make the code below work. Right-click on the project name in Solution Explorer and select Add Reference. Add a reference to Microsoft.Phone.Reactive and System.Observable assemblies.

Add the following using directives to the top of the page:

using Microsoft.Phone.Reactive;
using System.IO;
using System.Diagnostics;
using System.Text;

User authentication will happen inside the newly added FBLogin.xaml page—therefore your button click event handler should redirect the user to that page. Add the following code to the btnFacebook button click event (notice how you pass the MessageToPost parameter to the page):

private void btnFacebook_Click(object sender, RoutedEventArgs e)
           {
            NavigationService.Navigate(new
            Uri(String.Format("/FBLogin.xaml?MessageToPost={0}", textBox1.Text),
            UriKind.Relative));
           }

In the next step, you will define certain constants, such as permission types that an application needs, as well as a standard URL that Facebook gives to desktop and mobile developers to use upon successful authentication of an application (STR_FB_SuccessUrl constant below). Facebook developer documentation gives an in-depth overview of permission types available to your application; your sample application simply needs a permission to post to users' Facebook wall. Open FBLogin.xaml.cs page (right-click on FBLogin.xaml and select View Code) and add the following constant declarations to the top of the page (note that you must supply your application ID and your application secret key for the STR_FB_AppID and FB_AppSecret parameters correspondingly):

const string STR_FB_Permissions = "publish_stream";

const string STR_FB_SuccessUrl =
"http://www.facebook.com/connect/login_success.html";
        const string STR_FB_Login =
        "https://graph.facebook.com/oauth/authorize?display=wap&client_id={0}&redirect
        _uri={1}&scope={2}";
        const string FB_GetAccessToken =
        "https://graph.facebook.com/oauth/access_token?client_id={0}&redirect_uri={1}&
        client_secret={2}&code={3}";

        const string STR_Post = "POST";
        const string STR_Access_token = "access_token";
        const string STR_FB_AppId = "Your App ID";
        const string FB_AppSecret = "Your App Secret";
        const string STR_FormEncoded = "application/x-www-form-urlencoded";

In this step, you will use Reactive Extensions for .NET (Rx.NET) to subscribe to Webbrowser's control Navigated event. Rx.NET is ideally suited for working with events, such as navigation to and from facebook.com and the like. There is a whole chapter (Chapter 18) in this book devoted to learning and using Rx.NET. For right now, however, a simple understanding that you are reacting to the web browser's Navigated event and then creating a web request to Facebook in the code below is sufficient. Upon receiving the Navigated event, the code below parses out a session ID obtained from Facebook, then uses that session ID to compose a custom message to Facebook requesting an authentication token for the application. The actual posting of the message to the Facebook wall happens in the next step (Step 6). Make the FBLogin() constructor look like the following code:

public FBLogin()
        {
            InitializeComponent();

            this.Loaded += (sender, args) =>
            {
                var url = string.Format(STR_FB_Login, STR_FB_AppId,
                HttpUtility.UrlEncode(STR_FB_SuccessUrl), STR_FB_Permissions);
                IObservable<IEvent<NavigationEventArgs>> FBResponse;

                //register a subscription to FaceBook navigated event
                FBResponse = Observable.FromEvent<NavigationEventArgs>(webBrowser1,
                "Navigated");
                FBResponse.ObserveOn(Deployment.Current.Dispatcher)
                    .Subscribe(evt =>
                    {
                        //on successful user authentication event only
                        if
(evt.EventArgs.Uri.ToString().StartsWith(STR_FB_SuccessUrl))
                        {
                            //1. get a session ID from the query string
                            var sessionId =

evt.EventArgs.Uri.Query.Substring("?code=".Length);

                            //get the user and compose an authentication token request
                            string strTokenId = GetGraphToken(sessionId);
                            string strMessage = String.Empty;
                            NavigationContext.QueryString.TryGetValue("MessageToPost",
out

                        strMessage);

                            //2. get OAuth authentication token and use it to update
user's Facebook wall
                            UpdateWall("POST", strTokenId, strMessage);
                            NavigationService.GoBack();
                        }
                    },
                    ex =>
                    {
                        //log/process exceptions here

                    }
                );

                //invoke the navigation process
                webBrowser1.Navigate(new Uri(url, UriKind.Absolute));
            };
        }

Finally, you will code a couple of helper methods that will create a message to Facebook in the format that Facebook can understand, properly parse Facebook responses, and redirect. The first one of those methods is the GetGraphToken method shown here:

public static string GetGraphToken(string sessionId)
{
    string strAccessTokenUrl = String.Empty;
    try
    {
        strAccessTokenUrl = string.Format(FB_GetAccessToken, STR_FB_AppId,
        STR_FB_SuccessUrl, FB_AppSecret, sessionId);
    }
    catch (Exception exc)
    {
        System.Diagnostics.Debug.WriteLine("ERROR: " + exc.Message);
        System.Diagnostics.Debug.WriteLine(exc.StackTrace);
    }

    return strAccessTokenUrl;
}

The final helper method performs the heavy lifting of posting to Facebook. The gist of it is to use Rx.NET to asynchronously create a POST request to Facebook website, asking for a special OAuth authentication token and, upon successfully getting it, update user's Facebook wall. Don't feel overwhelmed by the length of the method below—you have learned the basic flow of OAuth authorization already, and this method simply implements the details of that flow inside a single function that you could reuse inside the applications that you build. Also, don't forget that you can always download all the code for this book instead of manually typing it in.