Introduction

Last week, we talked about get apps on devices for iPhone, Android, and Phone 7.
Then we talked about how to handle device rotation in iPhone and Android.
We mentioned how to do logging on iPhone and a little about the filesystem structure on iPhone.
Today, we are going to look at a second app on Phone 7.
It will illustrate how to handle events, and how to handle screen rotation.

Setting up our XAML file

To begin we create a new Phone 7 project.
Recall in the boiler plate code that is created for you, you get a MainPage.xaml and a C# file MainPage.xaml.cs which have the screen of our app and code to control it.
First, let's look at the XAML file by clicking on it in the Solution Explorer.
If you right click on the design view pane you can actual decide to display things in portrait and landscape mode.
You can see the orientation in the XAML file source as an attribute of the PhoneApplicationPage tag.
On one of the toolbars of VS you should see a hammer crossed by a wrench. Clicking on this (or CTRL-W) brings up a set of controls we can drag over to our XAML document.
We will first edit the XAML file, editing the TextBlock tags for the ApplicationTitle and PageTitle so that their Text attribute is more interesting.
Next we draw over a TextBlock which will print the value of a slider, a Slider, and a Button.
We can experiment with putting different text on the button, setting the Maximum, Minimum, and Value attributes of the slider, as well as just generally messing with Margin, Padding, and Alignments.

Setting Events to be Handled

Note each control has a Name attribute in XAML. This can be used to refer to the given control in the C# code.
You can also in the XAML code say what should happen when an event happens. For instance, we can add to our button a Click attribute, Click="button1_Click" to say the button1_Click method of the MainPage C# class associated to the MainPage.xaml file should handle the click event.
Another way, to get the same effect is to right-click on the Control in Design View and select Properties. Then click on the Events tab, and select the event you want to handle.
For a slider, we can handle the ValueChanged event, with a method slider1_ValueChanged
After setting these things up, let's look at some C# code.

MainPage.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;

namespace WindowsPhoneApplication1
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
            SupportedOrientations = SupportedPageOrientation.Portrait |
            SupportedPageOrientation.Landscape;
            this.OrientationChanged +=
                new EventHandler<OrientationChangedEventArgs>(OnOrientationChanged);
        }
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            slider1.Value = 50; 
        }

        private void slider1_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            if (sliderNum != null && slider1 != null)
            {
                sliderNum.Text = "" + Math.Floor(slider1.Value + 0.5);
            }
        }

        void OnOrientationChanged(object sender, OrientationChangedEventArgs e)
        {

            if ((e.Orientation & PageOrientation.Landscape) != 0)
            {

                sliderNum.FontSize = 30;

            }

            else // Portrait
            {

                sliderNum.FontSize = 16;
            }

        }
    }
}

Comments on the C# code

Notice C# has a notion of partial class which one doesn't have in Java.

One common use for this is to split, a class definition across several files.

You can also use it to get something like Aspect Oriented Programming.

Notice also our constructor calls initialize components. It is here that the magic glue between C# and XAML is done. i.e., Name's in the XAML will be objects with that field name in our instance of the C# class.

Notice in the constructor we declare which orientations we support.

We also use += to add an event handler new EventHandler(OnOrientationChanged) to handle orientation changes.

ScreenShots of our App

Quiz

Which of the following is true?

You don't need a certificate to get an app on an android device.
willAnimateSecondHalfOfRotationToInterfaceOrientation: could be overriden to move buttons around the screen when the iPhone is rotated.
If an Android app is in the run state, its state won't change if the screen is rotated.

Logging

As with the iPhone, Android supports logging events.
To use logging you need to import android.util.Log .
To see a list of log messages one can use LogCat by going to Window > Show View > Other... > Android > LogCat .
There are several types of log messages you can write:
- Log.e(): Errors
- Log.w(): Warnings
- Log.i(): Information
- Log.d(): Debugging
- Log.v(): Verbose

Logging Example

Each of these logging methods takes either two or three arguments. The first is the tag, which is usually String name of the Activity; the second parameter is the message you want. If there is a third parameter it is a Throwable object which might be caught be some enclosing code.
```
Log.i("Hw1", "Main ViewCreated");
```

Storing and Retrieving Data

Like the iPhone, Android has a mechanism for storing application information persistently.
The three main ways to do this are: using a SharedPreferences object, through the Android filesystem, or using SQLite.
We will look at each of these in turn.

Using Preferences

You access a android.content.SharedPreferences object through the Context you are working in.
Many Android classes have a reference to, or themselves extend from Context.
For example, both Activity and Service extend Context.
A Context object includes a getSharedPreferences(String prefname, int accessmode); method.
prefname will correspond to a file prefname.xml that is stored in /data/data/PACKAGE_NAME/shared_prefs in the Android phone's filesystem.
accessmode - corresponds to one a list of predefined static constants in Content. This in turn corresponds to Unix filesystem modes: Context.MODE_WORLD_READABLE, Context.MODE_WORLD_WRITEABLE, etc. You can OR these together using +.
If you want to browse the emulator's filesystem one can, in Eclipse, go to: Window > Show View > Other... > Android > File Explorer.

More on Using Preferences

You typically would write preferences, either when the activity starts in onCreate, or when you are just about to switch activities.

Here is an example of some code to open a SharedPreferences and write to it:

SharedPreferences myPref = getSharedPreferences("MY_APP_PREFS", 
   Context.MODE_WORLD_WRITEABLE + Context.MODE_WORLD_READABLE);

Log.i("My_Activity", 
   "Old Some_Key" + myPref.getString("Some_Key","Key did not exist") );
//second arg is returned if key did not exist

Editor myPrefEditor = myPref.edit();
myPrefEditor.putString("Some_Key", "Some Value");
myPrefEditor.commit();

Remembering the iPhone Filesystem

For both platforms, we said that there is a Unix-like filesystem we can access.
We saw we could view the contents of the iPhone Simulator filesystem by using Finder and going to:
```
~/Library/Application Support/iPhoneSimulator/User/
```

iPhone Filesystem Test

We could put the following code in some method that gets called during the start-up of our application:

NSArray *paths = NSSearchPathForDirectoriesInDomains(
    NSDocumentDirectory, NSUserDomainMask, YES); //look for Documents directories in user home folder 
                                                 //YES means expand tilde directories 

NSString *documentsDirectory = [paths objectAtIndex:0]; //Will only be one such dir so same

//For temporary dir could have done
//NSString *tempPath = NSTemporaryDirectory
	
NSString *filename = [documentsDirectory stringByAppendingPathComponent:@"theFile.txt"];
	
if([[NSFileManager defaultManager] fileExistsAtPath:filename])
{
   NSArray *readArray = [[NSArray alloc] initWithContentsOfFile:filename];
   NSLog(@"I read from the file: %@", [readArray objectAtIndex:0]);
   [readArray release];
}
NSMutableArray *storeArray = [[NSMutableArray alloc] init];
[storeArray addObject:@"Some interesting Data"];
[storeArray writeToFile:filename atomically:YES ];
  // writing such an array stores the data as XML much like a plist
NSLog(@"I wrote some data");
[storeArray release];

More Windows 7, More Persistence

Outline