The one major caveat I noticed was running in a 320x240 window @ 640x480, my O2 ran out of memory and started paging to the Virtual Memory (thank you gmemusage). I tested it twice to make sure, but a word to the wise, do not run Quake 2 in a window if you only have 128mb of memory. I'll test it out with 192mb shortly.

In case anyone was interested here is an updated list:

320x240
128mb - 180mhz R5000SC - 4.1 / 169.6 seconds
1024mb - 180mhz R5000SC - 14.9 / 46.3 seconds
1024mb - 300mhz R5200SC - 18.8 / 36.7 seconds

640x480
128mb - 180mhz R5000SC - 12.2 / 56.3 seconds
1024mb - 180mhz R5000SC - 12.4fps / 55.4 seconds
1024mb - 300mhz R5200SC - 14.5fps / 47.4 seconds

800x600
128mb - 180mhz R5000SC - 10.2 / 67.3 seconds
1024mb - 180mhz R5000SC - 10.3 / 67.2 seconds
1024mb - 300mhz R5200SC - 11.7 / 58.7 seconds

From what I have read so far, you have really two main options for detection. You can either use the return values of an ICMP request or if they are running IIS, using the WebResponse Headers to determine the version of IIS running (Apache will return something like Apache/1.3.23). Digging into ICMP, I realized that would require a good bit more reading so I chose the later for Stage 1 of my detection mechanism.

First off you need to create and return the WebResponse Header:

private string getHttpServerHeader(string ipAddress) {
     WebRequest webRequest = WebRequest.Create("http://" + ipAddress);
     WebResponse webResponse = null;

     string ServerHeader = String.Empty;

     try {
         webResponse = webRequest.GetResponse();
     } catch (WebException ex) {
          if (ex.Response.Headers != null) {
               ServerHeader = ex.Response.Headers["Server"];
          }
     } finally {
          if (webResponse != null) {
               webResponse.Close();
          }
     }

     return ServerHeader;
}

Then using the string result of that function:

private string getWebServerName(string server) {
    // IIS Detection from HTTP.SYS
    if (server.StartsWith("Microsoft-HTTPAPI")) {
        switch(server.Split('/')[1]) {
            case "1.0":
                return "IIS 6.0";
            case "2.0":
                return "IIS 6.0/7.x";
        }
    }

    // IIS Detection not from HTTP.SYS
    if (server.StartsWith("Microsoft-IIS")) {
        return "IIS " + server.Split('/')[1];
    }

    // If no conditional has trapped the Server entry, most likely the Web Server is either Apache or a masked IIS Server
    return server;
}

In reading about Fingerprinting it occurred to me that within IIS itself you can mask it with a custom Server Header like "WS" for instance. I doubt it would prevent a true attack, but it might save a couple bytes per connection over Microsoft-IIS 7.5

So for instance if you wanted to create a TCP socket object in .NET:

Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

or on UDP:

Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

Hunting around the WP7 SDK, I came across exactly what I was looking for: Observable Collections. In the "default" solution I had noticed this collection type previously, but always removed it in lieu of a Generic List Collection of whatever object I was using. The only caveat I found when using this approach is that you have to use the Dispatcher to update the collection on the UI Thread.

That being said here's a quick code sample:

In your Button or Page_Load Event set your Listbox ItemSource to the ObservableCollection you're going to populate:

lstBxResults.ItemsSource = App.ViewModel.Results;

Inside your ViewModel loop or asynchronously task (like a WCF service call for instance), wrap the addition of the result inside a Dispatcher Invoke:

System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => {
     Results.Add(new YourObject(e.Result));
});

With those 2 blocks you'll have your Listbox updated as they get added to the ObservableCollection from whatever time consuming task your phone is doing. Hope that helps someone out.

Using the following commands on the console:

timedemo 1
map demo1.dm2


Here's the results:

320x240
180mhz - 14.9 / 46.3 seconds
300mhz - 18.8 / 36.7 seconds

640x480
180mhz - 12.4fps / 55.4 seconds
300mhz - 14.5fps / 47.4 seconds

800x600
180mhz - 10.3 / 67.2 seconds
300mhz - 11.7 / 58.7 seconds

Kind of surprised at the results, I'll be testing my 180mhz R5000PC vs 180mhz R5000SC shortly to see what if any difference the Level 2 cache makes.

Silicon Graphics O2 showing the 1GB of RAM

I tried Quake II, it boots up a little bit quicker, but FPS wise, I didn't notice a difference.

Quake II on my O2

On a side note, I got SDLQuake to get all the way to the linking stage before giving up on it. For whatever reason using -lSDL was not including what looks like X11 or OpenAL libraries. I included both of those libraries and was still getting the errors.

Quake on my SGI O2

It did bring up old memories of my first LAN party in Summer of 1998 playing Quake, particularly E1M7 as seen in the picture. Definitely makes me want to have a Retrogaming LAN with Quake or Descent.

At the top of your class, add the following:

private string _imageUri;
private ImageView imageView;

private Boolean isMounted {
            get {
                return Android.OS.Environment.ExternalStorageState.Equals(Android.OS.Environment.MediaMounted);
            }
        }

Inside your Button Click Event:

     var uri = ContentResolver.Insert(isMounted ? Android.Provider.MediaStore.Images.Media.ExternalContentUri : Android.Provider.MediaStore.Images.Media.InternalContentUri, new ContentValues());
     _imageUri = uri.ToString();
     var i = new Intent(Android.Provider.MediaStore.ActionImageCapture);
     i.PutExtra(Android.Provider.MediaStore.ExtraOutput, uri);
     StartActivityForResult(i, 0);

Right below your Click Event function (or anywhere inside the Activity Class you're in):

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data) {
            if (resultCode == Result.Ok && requestCode == 0) {
                imageView = FindViewById<ImageView>(Resource.Id.ivThumbnail);
                imageView.DrawingCacheEnabled = true;

                imageView.SetImageURI(Android.Net.Uri.Parse(_imageUri));

                btnUploadImage.Visibility = ViewStates.Visible;
            }
        }

Then inside your "Upload Button Click" function:

Bitmap bitmap = imageView.GetDrawingCache(true);
MemoryStream ms = new MemoryStream();

// Note anything less than 50 will result in very pixelated images from what I've seen
bitmap.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, ms);

// At this point set your Byte[] variable/property with ms.ToArray();
// for instance I have a SyncFile object with a FileData Property, so I use
// SyncFile sFile = new SyncFile() { FileData = ms.ToArray(); };

Effectively this code captures a picture, puts it in an ImageView as a thumbnail on the Activity and then upon hitting your Upload Button it converts the image into a Byte Array after compressing it (or not like in my case) and from there call your WCF service upload function.

Hopefully that helped someone out.

Declare an enumeration object with each of your tabs:

public enum TABS {
   BasicInformation = 0,
   Detailinformation = 1,
   OptionalInforation = 2
};

Then add an abstract class to each of your Activity Objects:

public abstract class MyDroidActivity : Activity {
   public abstract bool SaveActivity();

   // Any other custom code you had
}
</code>

<strong>Then inside your inherited <code>Activity</code>:</strong>
<code>
public class BasicInfoActivity : MyDroidActivity {
   public override bool SaveActivity() {
         // Error handling to return false if for instance the fields weren't populated
   }
}

Then in your TabActivity Class:

private void SaveAllTabs() {
   TabHost.CurrentTab = (int)TABS.BasicInformation;

   BasicInformation biTab = (BasicInformation)LocalActivityManager.GetActivity(TabHost.CurrentTabTag);

if (!biTab.SaveActivity()) {
return;
}

// And continue with your other Tabs
}

Not the most elegant, but works. The inherited class and enumerations are not necessary, but helps keep things in order, especially if you have a larger application in my opinion.